1// Copyright (c) 2011 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 CHROME_BROWSER_PROFILES_PROFILE_KEYED_SERVICE_FACTORY_H_
6#define CHROME_BROWSER_PROFILES_PROFILE_KEYED_SERVICE_FACTORY_H_
7
8#include <map>
9
10class Profile;
11class ProfileDependencyManager;
12class ProfileKeyedService;
13
14// Base class for Factories that take a Profile object and return some service
15// on a one-to-one mapping. Each factory that derives from this class *must*
16// be a Singleton (only unit tests don't do that). See ThemeServiceFactory as
17// an example of how to derive from this class.
18//
19// We do this because services depend on each other and we need to control
20// shutdown/destruction order. In each derived classes' constructors, the
21// implementors must explicitly state which services are depended on.
22class ProfileKeyedServiceFactory {
23 public:
24  typedef ProfileKeyedService* (*FactoryFunction)(Profile* profile);
25
26#if defined(UNIT_TEST)
27  // Associate an already-created |service| with |profile| for this factory.
28  // The service may be a mock, or may be NULL to inhibit automatic creation of
29  // the service by the default function. A mock factory set with
30  // |set_test_factory| will be called instead if the service is NULL.
31  void ForceAssociationBetween(Profile* profile, ProfileKeyedService* service) {
32    Associate(profile, service);
33  }
34
35  // Sets the factory function to use to create mock instances of this service.
36  // The factory function will only be called for profiles for which
37  // |ForceAssociationBetween| has been previously called with a NULL service
38  // pointer, and therefore does not affect normal non-test profiles.
39  void set_test_factory(FactoryFunction factory) { factory_ = factory; }
40#endif
41
42 protected:
43  // ProfileKeyedServiceFactories must communicate with a
44  // ProfileDependencyManager. For all non-test code, write your subclass
45  // constructors like this:
46  //
47  //   MyServiceFactory::MyServiceFactory()
48  //     : ProfileKeyedServiceFactory(
49  //         ProfileDependencyManager::GetInstance())
50  //   {}
51  explicit ProfileKeyedServiceFactory(ProfileDependencyManager* manager);
52  virtual ~ProfileKeyedServiceFactory();
53
54  // Common implementation that maps |profile| to some service object. Deals
55  // with incognito profiles per subclass instructions with
56  // ServiceActiveInIncognito().
57  ProfileKeyedService* GetServiceForProfile(Profile* profile);
58
59  // The main public interface for declaring dependencies between services
60  // created by factories.
61  void DependsOn(ProfileKeyedServiceFactory* rhs);
62
63  // Maps |profile| to |provider| with debug checks to prevent duplication.
64  void Associate(Profile* profile, ProfileKeyedService* service);
65
66  // Returns a new instance of the service, casted to void* for our common
67  // storage.
68  virtual ProfileKeyedService* BuildServiceInstanceFor(
69      Profile* profile) const = 0;
70
71  // By default, if we are asked for a service with an Incognito profile, we
72  // pass back NULL. To redirect to the Incognito's original profile or to
73  // create another instance, even for Incognito windows, override one of the
74  // following methods:
75  virtual bool ServiceRedirectedInIncognito();
76  virtual bool ServiceHasOwnInstanceInIncognito();
77
78  // A helper object actually listens for notifications about Profile
79  // destruction, calculates the order in which things are destroyed and then
80  // does a two pass shutdown.
81  //
82  // First, ProfileShutdown() is called on every ServiceFactory and will
83  // usually call ProfileKeyedService::Shutdown(), which gives each
84  // ProfileKeyedService a chance to remove dependencies on other services that
85  // it may be holding.
86  //
87  // Secondly, ProfileDestroyed() is called on every ServiceFactory and the
88  // default implementation removes it from |mapping_| and deletes the pointer.
89  virtual void ProfileShutdown(Profile* profile);
90  virtual void ProfileDestroyed(Profile* profile);
91
92 private:
93  friend class ProfileDependencyManager;
94  friend class ProfileDependencyManagerUnittests;
95
96  // The mapping between a Profile and its service.
97  std::map<Profile*, ProfileKeyedService*> mapping_;
98
99  // Which ProfileDependencyManager we should communicate with. In real code,
100  // this will always be ProfileDependencyManager::GetInstance(), but unit
101  // tests will want to use their own copy.
102  ProfileDependencyManager* dependency_manager_;
103
104  // A mock factory function to use to create the service, used by tests.
105  FactoryFunction factory_;
106};
107
108#endif  // CHROME_BROWSER_PROFILES_PROFILE_KEYED_SERVICE_FACTORY_H_
109