1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// Copyright 2014 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 COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
#define COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
#include <memory>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "components/keyed_service/core/keyed_service_export.h"
#include "components/keyed_service/core/keyed_service_factory.h"
class BrowserContextDependencyManager;
class KeyedService;
namespace content {
class BrowserContext;
}
// Base class for Factories that take a BrowserContext object and return some
// service on a one-to-one mapping. Each factory that derives from this class
// *must* be a Singleton (only unit tests don't do that).
//
// We do this because services depend on each other and we need to control
// shutdown/destruction order. In each derived classes' constructors, the
// implementors must explicitly state which services are depended on.
class KEYED_SERVICE_EXPORT BrowserContextKeyedServiceFactory
: public KeyedServiceFactory {
public:
// Registers preferences used in this service on the pref service of
// |context|. This is the public interface and is safe to be called multiple
// times because testing code can have multiple services of the same type
// attached to a single |context|. Only test code is allowed to call this
// method.
// TODO(gab): This method can be removed entirely when
// PrefService::DeprecatedGetPrefRegistry() is phased out.
void RegisterUserPrefsOnBrowserContextForTest(
content::BrowserContext* context);
// A function that supplies the instance of a KeyedService for a given
// BrowserContext. This is used primarily for testing, where we want to feed
// a specific mock into the BCKSF system.
using TestingFactoryFunction =
std::unique_ptr<KeyedService> (*)(content::BrowserContext* context);
// Associates |factory| with |context| so that |factory| is used to create
// the KeyedService when requested. |factory| can be NULL to signal that
// KeyedService should be NULL. Multiple calls to SetTestingFactory() are
// allowed; previous services will be shut down.
void SetTestingFactory(content::BrowserContext* context,
TestingFactoryFunction factory);
// Associates |factory| with |context| and immediately returns the created
// KeyedService. Since the factory will be used immediately, it may not be
// NULL.
KeyedService* SetTestingFactoryAndUse(content::BrowserContext* context,
TestingFactoryFunction factory);
protected:
// BrowserContextKeyedServiceFactories must communicate with a
// BrowserContextDependencyManager. For all non-test code, write your subclass
// constructors like this:
//
// MyServiceFactory::MyServiceFactory()
// : BrowserContextKeyedServiceFactory(
// "MyService",
// BrowserContextDependencyManager::GetInstance())
// {}
BrowserContextKeyedServiceFactory(const char* name,
BrowserContextDependencyManager* manager);
~BrowserContextKeyedServiceFactory() override;
// Common implementation that maps |context| to some service object. Deals
// with incognito contexts per subclass instructions with
// GetBrowserContextRedirectedInIncognito() and
// GetBrowserContextOwnInstanceInIncognito() through the
// GetBrowserContextToUse() method on the base. If |create| is true, the
// service will be created using BuildServiceInstanceFor() if it doesn't
// already exist.
KeyedService* GetServiceForBrowserContext(content::BrowserContext* context,
bool create);
// Interface for people building a concrete FooServiceFactory: --------------
// Finds which browser context (if any) to use.
virtual content::BrowserContext* GetBrowserContextToUse(
content::BrowserContext* context) const;
// By default, we create instances of a service lazily and wait until
// GetForBrowserContext() is called on our subclass. Some services need to be
// created as soon as the BrowserContext has been brought up.
virtual bool ServiceIsCreatedWithBrowserContext() const;
// By default, TestingBrowserContexts will be treated like normal contexts.
// You can override this so that by default, the service associated with the
// TestingBrowserContext is NULL. (This is just a shortcut around
// SetTestingFactory() to make sure our contexts don't directly refer to the
// services they use.)
bool ServiceIsNULLWhileTesting() const override;
// Interface for people building a type of BrowserContextKeyedFactory: -------
// All subclasses of BrowserContextKeyedServiceFactory must return a
// KeyedService instead of just a BrowserContextKeyedBase.
virtual KeyedService* BuildServiceInstanceFor(
content::BrowserContext* context) const = 0;
// A helper object actually listens for notifications about BrowserContext
// destruction, calculates the order in which things are destroyed and then
// does a two pass shutdown.
//
// First, BrowserContextShutdown() is called on every ServiceFactory and will
// usually call KeyedService::Shutdown(), which gives each
// KeyedService a chance to remove dependencies on other
// services that it may be holding.
//
// Secondly, BrowserContextDestroyed() is called on every ServiceFactory
// and the default implementation removes it from |mapping_| and deletes
// the pointer.
virtual void BrowserContextShutdown(content::BrowserContext* context);
virtual void BrowserContextDestroyed(content::BrowserContext* context);
private:
friend class BrowserContextDependencyManagerUnittests;
// Registers any user preferences on this service. This is called by
// RegisterPrefsIfNecessaryForContext() and should be overriden by any service
// that wants to register profile-specific preferences.
virtual void RegisterProfilePrefs(
user_prefs::PrefRegistrySyncable* registry) {}
// KeyedServiceFactory:
std::unique_ptr<KeyedService> BuildServiceInstanceFor(
base::SupportsUserData* context) const final;
bool IsOffTheRecord(base::SupportsUserData* context) const final;
// KeyedServiceBaseFactory:
base::SupportsUserData* GetContextToUse(
base::SupportsUserData* context) const final;
bool ServiceIsCreatedWithContext() const final;
void ContextShutdown(base::SupportsUserData* context) final;
void ContextDestroyed(base::SupportsUserData* context) final;
void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) final;
DISALLOW_COPY_AND_ASSIGN(BrowserContextKeyedServiceFactory);
};
#endif // COMPONENTS_KEYED_SERVICE_CONTENT_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
|
