| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CHROME_BROWSER_EXTENSIONS_API_PROFILE_KEYED_API_FACTORY_H_ |
| #define CHROME_BROWSER_EXTENSIONS_API_PROFILE_KEYED_API_FACTORY_H_ |
| |
| #include "chrome/browser/extensions/extension_system_factory.h" |
| #include "chrome/browser/profiles/incognito_helpers.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "components/browser_context_keyed_service/browser_context_dependency_manager.h" |
| #include "components/browser_context_keyed_service/browser_context_keyed_service.h" |
| #include "components/browser_context_keyed_service/browser_context_keyed_service_factory.h" |
| |
| namespace extensions { |
| |
| template <typename T> |
| class ProfileKeyedAPIFactory; |
| |
| // Instantiations of ProfileKeyedAPIFactory should use this base class |
| // and also define a static const char* service_name() function (used in the |
| // BrowserContextKeyedBaseFactory constructor). These fields should |
| // be accessible to the ProfileKeyedAPIFactory for the service. |
| class ProfileKeyedAPI : public BrowserContextKeyedService { |
| protected: |
| // Defaults for flags that control ProfileKeyedAPIFactory behavior. |
| // See BrowserContextKeyedBaseFactory for usage. |
| static const bool kServiceRedirectedInIncognito = false; |
| static const bool kServiceIsNULLWhileTesting = false; |
| static const bool kServiceHasOwnInstanceInIncognito = false; |
| static const bool kServiceIsCreatedWithBrowserContext = true; |
| |
| // Users of this factory template must define a GetFactoryInstance() |
| // and manage their own instances (typically using LazyInstance or |
| // Singleton), because those cannot be included in more than one |
| // translation unit (and thus cannot be initialized in a header file). |
| // |
| // In the header file, declare GetFactoryInstance(), e.g.: |
| // class ProcessesAPI { |
| // ... |
| // public: |
| // static ProfileKeyedAPIFactory<ProcessesAPI>* GetFactoryInstance(); |
| // }; |
| // |
| // In the cc file, provide the implementation, e.g.: |
| // static base::LazyInstance<ProfileKeyedAPIFactory<ProcessesAPI> > |
| // g_factory = LAZY_INSTANCE_INITIALIZER; |
| // |
| // // static |
| // ProfileKeyedAPIFactory<ProcessesAPI>* |
| // ProcessesAPI::GetFactoryInstance() { |
| // return &g_factory.Get(); |
| // } |
| }; |
| |
| // A template for factories for BrowserContextKeyedServices that manage |
| // extension APIs. T is a BrowserContextKeyedService that uses this factory |
| // template instead of its own separate factory definition to manage its |
| // per-profile instances. |
| template <typename T> |
| class ProfileKeyedAPIFactory : public BrowserContextKeyedServiceFactory { |
| public: |
| static T* GetForProfile(Profile* profile) { |
| return static_cast<T*>( |
| T::GetFactoryInstance()->GetServiceForBrowserContext(profile, true)); |
| } |
| |
| // Declare dependencies on other factories. |
| // By default, ExtensionSystemFactory is the only dependency; however, |
| // specializations can override this. Declare your specialization in |
| // your header file after the ProfileKeyedAPI class definition. |
| // Then in the cc file (or inline in the header), define it, e.g.: |
| // template <> |
| // ProfileKeyedAPIFactory<PushMessagingAPI>::DeclareFactoryDependencies() { |
| // DependsOn(ExtensionSystemFactory::GetInstance()); |
| // DependsOn(ProfileSyncServiceFactory::GetInstance()); |
| // } |
| void DeclareFactoryDependencies() { |
| DependsOn(ExtensionSystemFactory::GetInstance()); |
| } |
| |
| ProfileKeyedAPIFactory() |
| : BrowserContextKeyedServiceFactory( |
| T::service_name(), |
| BrowserContextDependencyManager::GetInstance()) { |
| DeclareFactoryDependencies(); |
| } |
| |
| virtual ~ProfileKeyedAPIFactory() { |
| } |
| |
| private: |
| // BrowserContextKeyedServiceFactory implementation. |
| virtual BrowserContextKeyedService* BuildServiceInstanceFor( |
| content::BrowserContext* profile) const OVERRIDE { |
| return new T(static_cast<Profile*>(profile)); |
| } |
| |
| // BrowserContextKeyedBaseFactory implementation. |
| // These can be effectively overridden with template specializations. |
| virtual content::BrowserContext* GetBrowserContextToUse( |
| content::BrowserContext* context) const OVERRIDE { |
| if (T::kServiceRedirectedInIncognito) |
| return chrome::GetBrowserContextRedirectedInIncognito(context); |
| |
| if (T::kServiceHasOwnInstanceInIncognito) |
| return chrome::GetBrowserContextOwnInstanceInIncognito(context); |
| |
| return BrowserContextKeyedServiceFactory::GetBrowserContextToUse(context); |
| } |
| |
| virtual bool ServiceIsCreatedWithBrowserContext() const OVERRIDE { |
| return T::kServiceIsCreatedWithBrowserContext; |
| } |
| |
| virtual bool ServiceIsNULLWhileTesting() const OVERRIDE { |
| return T::kServiceIsNULLWhileTesting; |
| } |
| |
| DISALLOW_COPY_AND_ASSIGN(ProfileKeyedAPIFactory); |
| }; |
| |
| } // namespace extensions |
| |
| #endif // CHROME_BROWSER_EXTENSIONS_API_PROFILE_KEYED_API_FACTORY_H_ |