Home | History | Annotate | Download | only in content 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
      6 #define COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
      7 
      8 #include <map>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/compiler_specific.h"
     12 #include "components/keyed_service/content/browser_context_keyed_base_factory.h"
     13 #include "components/keyed_service/core/keyed_service.h"
     14 #include "components/keyed_service/core/keyed_service_export.h"
     15 
     16 class BrowserContextDependencyManager;
     17 class KeyedService;
     18 
     19 // Base class for Factories that take a BrowserContext object and return some
     20 // service on a one-to-one mapping. Each factory that derives from this class
     21 // *must* be a Singleton (only unit tests don't do that).
     22 //
     23 // We do this because services depend on each other and we need to control
     24 // shutdown/destruction order. In each derived classes' constructors, the
     25 // implementors must explicitly state which services are depended on.
     26 class KEYED_SERVICE_EXPORT BrowserContextKeyedServiceFactory
     27     : public BrowserContextKeyedBaseFactory {
     28  public:
     29   // A function that supplies the instance of a KeyedService for a given
     30   // BrowserContext. This is used primarily for testing, where we want to feed
     31   // a specific mock into the BCKSF system.
     32   typedef KeyedService* (*TestingFactoryFunction)(
     33       content::BrowserContext* context);
     34 
     35   // Associates |factory| with |context| so that |factory| is used to create
     36   // the KeyedService when requested.  |factory| can be NULL to signal that
     37   // KeyedService should be NULL. Multiple calls to SetTestingFactory() are
     38   // allowed; previous services will be shut down.
     39   void SetTestingFactory(content::BrowserContext* context,
     40                          TestingFactoryFunction factory);
     41 
     42   // Associates |factory| with |context| and immediately returns the created
     43   // KeyedService. Since the factory will be used immediately, it may not be
     44   // NULL.
     45   KeyedService* SetTestingFactoryAndUse(content::BrowserContext* context,
     46                                         TestingFactoryFunction factory);
     47 
     48  protected:
     49   // BrowserContextKeyedServiceFactories must communicate with a
     50   // BrowserContextDependencyManager. For all non-test code, write your subclass
     51   // constructors like this:
     52   //
     53   //   MyServiceFactory::MyServiceFactory()
     54   //     : BrowserContextKeyedServiceFactory(
     55   //         "MyService",
     56   //         BrowserContextDependencyManager::GetInstance())
     57   //   {}
     58   BrowserContextKeyedServiceFactory(const char* name,
     59                                     BrowserContextDependencyManager* manager);
     60   virtual ~BrowserContextKeyedServiceFactory();
     61 
     62   // Common implementation that maps |context| to some service object. Deals
     63   // with incognito contexts per subclass instructions with
     64   // GetBrowserContextRedirectedInIncognito() and
     65   // GetBrowserContextOwnInstanceInIncognito() through the
     66   // GetBrowserContextToUse() method on the base.  If |create| is true, the
     67   // service will be created using BuildServiceInstanceFor() if it doesn't
     68   // already exist.
     69   KeyedService* GetServiceForBrowserContext(content::BrowserContext* context,
     70                                             bool create);
     71 
     72   // Maps |context| to |service| with debug checks to prevent duplication.
     73   void Associate(content::BrowserContext* context, KeyedService* service);
     74 
     75   // Removes the mapping from |context| to a service.
     76   void Disassociate(content::BrowserContext* context);
     77 
     78   // All subclasses of BrowserContextKeyedServiceFactory must return a
     79   // KeyedService instead of just a BrowserContextKeyedBase.
     80   virtual KeyedService* BuildServiceInstanceFor(
     81       content::BrowserContext* context) const = 0;
     82 
     83   // A helper object actually listens for notifications about BrowserContext
     84   // destruction, calculates the order in which things are destroyed and then
     85   // does a two pass shutdown.
     86   //
     87   // First, BrowserContextShutdown() is called on every ServiceFactory and will
     88   // usually call KeyedService::Shutdown(), which gives each
     89   // KeyedService a chance to remove dependencies on other
     90   // services that it may be holding.
     91   //
     92   // Secondly, BrowserContextDestroyed() is called on every ServiceFactory
     93   // and the default implementation removes it from |mapping_| and deletes
     94   // the pointer.
     95   virtual void BrowserContextShutdown(content::BrowserContext* context)
     96       OVERRIDE;
     97   virtual void BrowserContextDestroyed(content::BrowserContext* context)
     98       OVERRIDE;
     99 
    100   virtual void SetEmptyTestingFactory(content::BrowserContext* context)
    101       OVERRIDE;
    102   virtual bool HasTestingFactory(content::BrowserContext* context) OVERRIDE;
    103   virtual void CreateServiceNow(content::BrowserContext* context) OVERRIDE;
    104 
    105  private:
    106   friend class BrowserContextDependencyManager;
    107   friend class BrowserContextDependencyManagerUnittests;
    108 
    109   typedef std::map<content::BrowserContext*, KeyedService*>
    110       BrowserContextKeyedServices;
    111   typedef std::map<content::BrowserContext*, TestingFactoryFunction>
    112       BrowserContextOverriddenTestingFunctions;
    113 
    114   // The mapping between a BrowserContext and its service.
    115   BrowserContextKeyedServices mapping_;
    116 
    117   // The mapping between a BrowserContext and its overridden
    118   // TestingFactoryFunction.
    119   BrowserContextOverriddenTestingFunctions testing_factories_;
    120 
    121   DISALLOW_COPY_AND_ASSIGN(BrowserContextKeyedServiceFactory);
    122 };
    123 
    124 #endif  // COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
    125