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
151
|
// Copyright 2014 The Chromium Authors
// 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_REFCOUNTED_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
#define COMPONENTS_KEYED_SERVICE_CONTENT_REFCOUNTED_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
#include "base/compiler_specific.h"
#include "base/functional/callback.h"
#include "base/memory/ref_counted.h"
#include "components/keyed_service/core/keyed_service_export.h"
#include "components/keyed_service/core/refcounted_keyed_service_factory.h"
class BrowserContextDependencyManager;
class RefcountedKeyedService;
namespace content {
class BrowserContext;
}
// A specialized BrowserContextKeyedServiceFactory that manages a
// RefcountedThreadSafe<>.
//
// While the factory returns RefcountedThreadSafe<>s, the factory itself is a
// base::NotThreadSafe. Only call methods on this object on the UI thread.
//
// Implementers of RefcountedKeyedService should note that we guarantee that
// ShutdownOnUIThread() is called on the UI thread, but actual object
// destruction can happen anywhere.
class KEYED_SERVICE_EXPORT RefcountedBrowserContextKeyedServiceFactory
: public RefcountedKeyedServiceFactory {
public:
// A callback that supplies the instance of a KeyedService for a given
// BrowserContext. This is used primarily for testing, where we want to feed
// a specific test double into the BCKSF system.
using TestingFactory =
base::OnceCallback<scoped_refptr<RefcountedKeyedService>(
content::BrowserContext* context)>;
RefcountedBrowserContextKeyedServiceFactory(
const RefcountedBrowserContextKeyedServiceFactory&) = delete;
RefcountedBrowserContextKeyedServiceFactory& operator=(
const RefcountedBrowserContextKeyedServiceFactory&) = delete;
// Associates |testing_factory| with |context| so that |testing_factory| is
// used to create the KeyedService when requested. |testing_factory| can be
// empty to signal that KeyedService should be null. Multiple calls to
// SetTestingFactory() are allowed; previous services will be shut down.
void SetTestingFactory(content::BrowserContext* context,
TestingFactory testing_factory);
// Associates |testing_factory| with |context| and immediately returns the
// created KeyedService. Since the factory will be used immediately, it may
// not be empty.
scoped_refptr<RefcountedKeyedService> SetTestingFactoryAndUse(
content::BrowserContext* context,
TestingFactory testing_factory);
protected:
// RefcountedBrowserContextKeyedServiceFactories must communicate with a
// BrowserContextDependencyManager. For all non-test code, write your subclass
// constructors like this:
//
// MyServiceFactory::MyServiceFactory()
// : RefcountedBrowserContextKeyedServiceFactory(
// "MyService",
// BrowserContextDependencyManager::GetInstance())
// {}
RefcountedBrowserContextKeyedServiceFactory(
const char* name,
BrowserContextDependencyManager* manager);
~RefcountedBrowserContextKeyedServiceFactory() 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.
scoped_refptr<RefcountedKeyedService> GetServiceForBrowserContext(
content::BrowserContext* context,
bool create);
// Interface for people building a concrete FooServiceFactory: --------------
// Finds which browser context (if any) to use.
//
// Should return nullptr when the service should not be created for the given
// |context|.
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.
//
// This should not return nullptr; instead, return nullptr from
// `GetBrowserContextToUse()`.
virtual scoped_refptr<RefcountedKeyedService> 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 should be overriden by
// any service that wants to register profile-specific preferences.
virtual void RegisterProfilePrefs(
user_prefs::PrefRegistrySyncable* registry) {}
// RefcountedKeyedServiceFactory:
scoped_refptr<RefcountedKeyedService> BuildServiceInstanceFor(
void* context) const final;
// KeyedServiceBaseFactory:
void* GetContextToUse(void* context) const final;
bool ServiceIsCreatedWithContext() const final;
void ContextShutdown(void* context) final;
void ContextDestroyed(void* context) final;
void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) final;
};
#endif // COMPONENTS_KEYED_SERVICE_CONTENT_REFCOUNTED_BROWSER_CONTEXT_KEYED_SERVICE_FACTORY_H_
|
