67 // SetTestingFactory() to make sure our contexts don't directly refer to the

68 // services they use.)

69 bool ServiceIsNULLWhileTesting() const override;

70

71 // Interface for people building a type of BrowserContextKeyedFactory: -------

96 user_prefs::PrefRegistrySyncable* registry) {}

97

98 // Because of ServiceIsNULLWhileTesting(), we need a way to tell different

99 // subclasses that they should disable testing.

100 virtual void SetEmptyTestingFactory(content::BrowserContext* context) = 0;

329 return "InputMethodAPI";

330 }

331 static const bool kServiceIsNULLWhileTesting = true;

332

333 content::BrowserContext* const context_;

92 }

93

94 bool WebViewWebDataServiceWrapperFactory::ServiceIsNULLWhileTesting() const {

95 return true;

96 }

95 }

96

97 bool BrowserContextKeyedBaseFactory::ServiceIsNULLWhileTesting() const {

98 return false;

99 }

110 return "ManagedModeAPI";

111 }

112 static const bool kServiceIsNULLWhileTesting = true;

113

114 // Created lazily upon OnListenerAdded.

74 virtual void RegisterUserPrefs(PrefRegistrySyncable* registry) OVERRIDE;

75 virtual bool ServiceRedirectedInIncognito() const OVERRIDE;

76 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

77 virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;

78

68 return "WebcamPrivateAPI";

69 }

70 static const bool kServiceIsNULLWhileTesting = true;

71 static const bool kServiceRedirectedInIncognito = true;

72

85

86 bool ChromeSpeechRecognitionPreferences::Factory::

87 ServiceIsNULLWhileTesting() const {

88 return true;

89 }

64 return "PreferenceAPI";

65 }

66 static const bool kServiceIsNULLWhileTesting = true;

67

68 // Created lazily upon OnListenerAdded.

216 return "ManagementAPI";

217 }

218 static const bool kServiceIsNULLWhileTesting = true;

219

220 // Created lazily upon OnListenerAdded.

93 }

94 static const bool kServiceRedirectedInIncognito = true;

95 static const bool kServiceIsNULLWhileTesting = true;

96

97 scoped_ptr<MediaPlayerEventRouter> media_player_event_router_;

86 return "FontSettingsAPI";

87 }

88 static const bool kServiceIsNULLWhileTesting = true;

89

90 scoped_ptr<FontSettingsEventRouter> font_settings_event_router_;

127 }

128

129 bool EasyUnlockServiceFactory::ServiceIsNULLWhileTesting() const {

130 // Don't create the service for TestingProfile used in unit_tests because

131 // EasyUnlockService uses ExtensionSystem::ready().Post, which expects

127 }

128 static const bool kServiceHasOwnInstanceInIncognito = true;

129 static const bool kServiceIsNULLWhileTesting = true;

130

131 int current_rules_registry_id_;

43 static const char* service_name() { return "BluetoothLowEnergyAPI"; }

44 static const bool kServiceRedirectedInIncognito = true;

45 static const bool kServiceIsNULLWhileTesting = true;

46

47 private:

105 }

106

107 bool ProfileKeyedBaseFactory::ServiceIsNULLWhileTesting() const {

108 return false;

109 }

84 static const char* service_name() { return "HidDeviceManager"; }

85 static const bool kServiceHasOwnInstanceInIncognito = true;

86 static const bool kServiceIsNULLWhileTesting = true;

87

88 // EventRouter::Observer:

124 }

125

126 bool FeatureNotificationGuideServiceFactory::ServiceIsNULLWhileTesting() const {

127 return true;

128 }

190 return "CookiesAPI";

191 }

192 static const bool kServiceIsNULLWhileTesting = true;

193

194 // Created lazily upon OnListenerAdded.

92 }

93

94 bool AuthenticationServiceFactory::ServiceIsNULLWhileTesting() const {

95 return true;

96 }

101 }

102

103 bool IOSChromePasswordStoreFactory::ServiceIsNULLWhileTesting() const {

104 return true;

105 }

52 // test BrowserContexts - these contexts will not create services for any

53 // BrowserContextKeyedBaseFactories that return true from

54 // ServiceIsNULLWhileTesting().

55 void CreateBrowserContextServicesForTest(content::BrowserContext* context);

56

76 content::BrowserContext* context) const override;

77 bool ServiceIsCreatedWithBrowserContext() const override;

78 bool ServiceIsNULLWhileTesting() const override;

79

80 scoped_ptr<VerifyDelegateFactory> verify_factory_;

68 content::BrowserContext* profile) const override;

69 bool ServiceIsCreatedWithBrowserContext() const override;

70 bool ServiceIsNULLWhileTesting() const override;

71 };

72

118 content::BrowserContext* profile) const OVERRIDE;

119 virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;

120 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

121 };

122

129 return "PushMessagingAPI";

130 }

131 static const bool kServiceIsNULLWhileTesting = true;

132

133 // content::NotificationDelegate implementation.

83 // BrowserContextKeyedAPI implementation.

84 static const char* service_name() { return "TtsAPI"; }

85 static const bool kServiceIsNULLWhileTesting = true;

86 };

87

81 return "MediaGalleriesPrivateAPI";

82 }

83 static const bool kServiceIsNULLWhileTesting = true;

84

85 // Current profile.

73 static const bool kServiceRedirectedInIncognito = true;

74 static const bool kServiceIsCreatedWithBrowserContext = false;

75 static const bool kServiceIsNULLWhileTesting = true;

76

77 private:

54 return "SessionRestoreAPI";

55 }

56 static const bool kServiceIsNULLWhileTesting = true;

57 };

58

111 }

112

113 bool WebDataServiceFactory::ServiceIsNULLWhileTesting() const {

114 return true;

115 }

62 }

63

64 bool InMemoryURLIndexFactory::ServiceIsNULLWhileTesting() const {

65 return true;

66 }

51 }

52

53 bool FaviconServiceFactory::ServiceIsNULLWhileTesting() const {

54 return true;

55 }

84 }

85

86 bool PluginPrefsFactory::ServiceIsNULLWhileTesting() const {

87 return true;

88 }

74 content::BrowserContext* GetBrowserContextToUse(

75 content::BrowserContext* context) const override;

76 bool ServiceIsNULLWhileTesting() const override;

77 };

78

61 }

62

63 bool UserCloudPolicyInvalidatorFactory::ServiceIsNULLWhileTesting() const {

64 // Not used in tests.

65 return true;

32 content::BrowserContext* context) const override;

33 bool ServiceIsCreatedWithBrowserContext() const override;

34 bool ServiceIsNULLWhileTesting() const override;

35

36 private:

45 static const char* service_name() { return "SerialEventDispatcher"; }

46 static const bool kServiceHasOwnInstanceInIncognito = true;

47 static const bool kServiceIsNULLWhileTesting = true;

48

49 struct ReceiveParams {

61 }

62

63 bool BrowserStateKeyedServiceFactory::ServiceIsNULLWhileTesting() const {

64 return KeyedServiceBaseFactory::ServiceIsNULLWhileTesting();

53 static const char* service_name() { return "TCPServerSocketEventDispatcher"; }

54 static const bool kServiceHasOwnInstanceInIncognito = true;

55 static const bool kServiceIsNULLWhileTesting = true;

56

57 // base::Bind supports methods with up to 6 parameters. AcceptParams is used

72 }

73

74 bool ShortcutsBackendFactory::ServiceIsNULLWhileTesting() const {

75 return true;

76 }

68 }

69

70 bool RefcountedBrowserStateKeyedServiceFactory::ServiceIsNULLWhileTesting()

71 const {

72 return KeyedServiceBaseFactory::ServiceIsNULLWhileTesting();

83 static const char* service_name() { return "contentBlockingAPI"; }

84

85 static const bool kServiceIsNULLWhileTesting = true;

86 static const bool kServiceRedirectedInIncognito = true;

87

94 // BrowserContextKeyedAPI implementation.

95 static const char* service_name() { return "CalendarAPI"; }

96 static const bool kServiceIsNULLWhileTesting = true;

97 static const bool kServiceRedirectedInIncognito = true;

98

69 return "StreamsPrivateAPI";

70 }

71 static const bool kServiceIsNULLWhileTesting = true;

72 static const bool kServiceRedirectedInIncognito = true;

73

213 return "InputImeAPI";

214 }

215 static const bool kServiceIsNULLWhileTesting = true;

216

217 Profile* const profile_;

74 KeyedService* BuildServiceInstanceFor(

75 content::BrowserContext* profile) const override;

76 bool ServiceIsNULLWhileTesting() const override;

77

78 DISALLOW_COPY_AND_ASSIGN(WebDataServiceFactory);

82 }

83

84 bool WhitelistManagerFactory::ServiceIsNULLWhileTesting() const {

85 return true;

86 }

78 return "TtsAPI";

79 }

80 static const bool kServiceIsNULLWhileTesting = true;

81 };

82

50 }

51

52 bool NetworkingPrivateEventRouterFactory::ServiceIsNULLWhileTesting() const {

53 return true;

54 }

52 IOSChromeTabRestoreServiceFactory::~IOSChromeTabRestoreServiceFactory() {}

53

54 bool IOSChromeTabRestoreServiceFactory::ServiceIsNULLWhileTesting() const {

55 return true;

56 }

27 // individual tests or they can create their own instances of the service.

28 // * In unittests: CertDbInitializer is not created by default (see

29 // `ServiceIsNULLWhileTesting()`).

30 class CertDbInitializerFactory : public BrowserContextKeyedServiceFactory {

31 public:

50 KeyedService* BuildServiceInstanceFor(

51 content::BrowserContext* context) const override;

52 bool ServiceIsNULLWhileTesting() const override;

53 content::BrowserContext* GetBrowserContextToUse(

54 content::BrowserContext* context) const override;

56 }

57

58 bool PrerenderServiceFactory::ServiceIsNULLWhileTesting() const {

59 // PrerenderService is omitted while testing because it complicates

60 // measurements in perf tests.

96 }

97

98 bool HistoryServiceFactory::ServiceIsNULLWhileTesting() const {

99 return true;

100 }

33 // ProfileKeyedServiceFactory:

34 virtual bool ServiceRedirectedInIncognito() const OVERRIDE;

35 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

36 virtual ProfileKeyedService* BuildServiceInstanceFor(

37 content::BrowserContext* profile) const OVERRIDE;

117 }

118

119 bool OptimizationGuideServiceFactory::ServiceIsNULLWhileTesting() const {

120 return true;

121 }

54 }

55

56 bool AutofillPrivateEventRouterFactory::ServiceIsNULLWhileTesting() const {

57 return false;

58 }

42

43 // If set to true, GetForProfile returns NULL for TestingBrowserContexts.

44 static const bool kServiceIsNULLWhileTesting = false;

45

46 // Users of this factory template must define a GetFactoryInstance()

131 }

132

133 bool ServiceIsNULLWhileTesting() const override {

134 return T::kServiceIsNULLWhileTesting;

48 virtual void RegisterUserPrefs(PrefRegistrySyncable* registry) OVERRIDE;

49 virtual bool ServiceRedirectedInIncognito() const OVERRIDE;

50 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

51

52 DISALLOW_COPY_AND_ASSIGN(PasswordStoreFactory);

59 return "InputMethodAPI";

60 }

61 static const bool kServiceIsNULLWhileTesting = true;

62

63 Profile* const profile_;

36 virtual bool ServiceHasOwnInstanceInIncognito() const OVERRIDE;

37 virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;

38 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

39 };

40

97 }

98

99 bool AppListSyncableServiceFactory::ServiceIsNULLWhileTesting() const {

100 return true;

101 }

89 // BrowserContextKeyedAPI implementation.

90 static const char* service_name() { return "WebstoreAPI"; }

91 static const bool kServiceIsNULLWhileTesting = true;

92

93 ObservedInstallInfoList download_progress_listeners_;

67 KeyedServiceBaseFactory* factory =

68 static_cast<KeyedServiceBaseFactory*>(dependency_node);

69 if (is_testing_context && factory->ServiceIsNULLWhileTesting() &&

70 !factory->HasTestingFactory(context)) {

71 factory->SetEmptyTestingFactory(context);

51 static const char* service_name() { return "TCPSocketEventDispatcher"; }

52 static const bool kServiceHasOwnInstanceInIncognito = true;

53 static const bool kServiceIsNULLWhileTesting = true;

54

55 // base::Bind supports methods with up to 6 parameters. ReadParams is used

78 }

79

80 bool ChromePasswordProtectionServiceFactory::ServiceIsNULLWhileTesting() const {

81 return true;

82 }

101 }

102

103 bool KeyedServiceBaseFactory::ServiceIsNULLWhileTesting() const {

104 return false;

105 }

69 static_cast<KeyedServiceBaseFactory*>(dependency_node);

70 base::SupportsUserData* typed_context = factory->GetTypedContext(context);

71 if (is_testing_context && factory->ServiceIsNULLWhileTesting() &&

72 !factory->HasTestingFactory(typed_context)) {

73 factory->SetEmptyTestingFactory(typed_context);

26 // See ProfileKeyedBaseFactory for usage.

27 static const bool kServiceRedirectedInIncognito = false;

28 static const bool kServiceIsNULLWhileTesting = false;

29

30 // Users of this factory template must define a GetFactoryInstance()

102 }

103

104 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE {

105 return T::kServiceIsNULLWhileTesting;

131 return "SessionsAPI";

132 }

133 static const bool kServiceIsNULLWhileTesting = true;

134

135 // Created lazily upon OnListenerAdded.

47 web::BrowserState* GetBrowserStateToUse(

48 web::BrowserState* context) const override;

49 bool ServiceIsNULLWhileTesting() const override;

50

51 DISALLOW_COPY_AND_ASSIGN(BookmarkModelFactory);

37

38 virtual void RegisterUserPrefs(PrefRegistrySyncable* registry) OVERRIDE;

39 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

40

41 DISALLOW_COPY_AND_ASSIGN(GAIAInfoUpdateServiceFactory);

73 }

74

75 bool BrowserContextKeyedServiceFactory::ServiceIsNULLWhileTesting() const {

76 return KeyedServiceBaseFactory::ServiceIsNULLWhileTesting();

44 return "TabsWindowsAPI";

45 }

46 static const bool kServiceIsNULLWhileTesting = true;

47

48 scoped_ptr<WindowsEventRouter> windows_event_router_;

104 }

105

106 bool TemplateURLServiceFactory::ServiceIsNULLWhileTesting() const {

107 return true;

108 }

182 // BrowserContextKeyedAPI implementation.

183 static const char* service_name() { return "AutotestPrivateAPI"; }

184 static const bool kServiceIsNULLWhileTesting = true;

185 static const bool kServiceRedirectedInIncognito = true;

186

53 virtual BrowserContextKeyedService* BuildServiceInstanceFor(

54 content::BrowserContext* context) const OVERRIDE;

55 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

56 virtual content::BrowserContext* GetBrowserContextToUse(

57 content::BrowserContext* context) const OVERRIDE;

47 }

48

49 bool GAIAInfoUpdateServiceFactory::ServiceIsNULLWhileTesting() const {

50 return true;

51 }

83 return "ScreenlockPrivateEventRouter";

84 }

85 static const bool kServiceIsNULLWhileTesting = true;

86 static const bool kServiceRedirectedInIncognito = true;

87

42 }

43

44 bool VpnServiceFactory::ServiceIsNULLWhileTesting() const {

45 return true;

46 }

53 }

54

55 bool SettingsPrivateEventRouterFactory::ServiceIsNULLWhileTesting() const {

56 return false;

57 }

81 }

82

83 bool SpellcheckServiceFactory::ServiceIsNULLWhileTesting() const {

84 return true;

85 }

51 content::BrowserContext* context) const override;

52 bool ServiceIsCreatedWithBrowserContext() const override;

53 bool ServiceIsNULLWhileTesting() const override;

54 KeyedService* BuildServiceInstanceFor(

55 content::BrowserContext* context) const override;

35 // Create services for test BrowserContexts - these contexts will not create

36 // services for any SimpleKeyedBaseFactories that return true from

37 // ServiceIsNULLWhileTesting().

38 void CreateServicesForTest(SimpleFactoryKey* key);

39

58 }

59

60 bool UserCloudPolicyTokenForwarderFactory::ServiceIsNULLWhileTesting() const {

61 // This is only needed in a handful of tests that manually create the object.

62 return true;

58 static const char* service_name() { return "BluetoothSocketEventDispatcher"; }

59 static const bool kServiceHasOwnInstanceInIncognito = true;

60 static const bool kServiceIsNULLWhileTesting = true;

61

62 // base::Bind supports methods with up to 6 parameters. SocketParams is used

68 }

69

70 bool RefcountedBrowserContextKeyedServiceFactory::ServiceIsNULLWhileTesting()

71 const {

72 return KeyedServiceBaseFactory::ServiceIsNULLWhileTesting();

56 }

57

58 bool PasswordsPrivateEventRouterFactory::ServiceIsNULLWhileTesting() const {

59 return true;

60 }

53 KeyedService* BuildServiceInstanceFor(

54 content::BrowserContext* context) const override;

55 bool ServiceIsNULLWhileTesting() const override;

56 content::BrowserContext* GetBrowserContextToUse(

57 content::BrowserContext* context) const override;

88 }

89

90 bool SessionServiceFactory::ServiceIsNULLWhileTesting() const {

91 return true;

92 }

72 web::BrowserState* GetBrowserStateToUse(

73 web::BrowserState* context) const override;

74 bool ServiceIsNULLWhileTesting() const override;

75 };

76

75 }

76

77 bool DomainDiversityReporterFactory::ServiceIsNULLWhileTesting() const {

78 return true;

79 }

78 }

79

80 bool ManagedBookmarkServiceFactory::ServiceIsNULLWhileTesting() const {

81 return true;

82 }

67 }

68

69 bool PasswordManagerSettingsServiceFactory::ServiceIsNULLWhileTesting() const {

70 return true;

71 }

40 static const char* service_name() { return "BluetoothPrivateAPI"; }

41 static const bool kServiceRedirectedInIncognito = true;

42 static const bool kServiceIsNULLWhileTesting = true;

43

44 private:

72 }

73

74 bool AutocompleteClassifierFactory::ServiceIsNULLWhileTesting() const {

75 return true;

76 }

76 }

77 // Override the default so the service is not created in tests.

78 static const bool kServiceIsNULLWhileTesting = true;

79 };

80

81 return "HistoryAPI";

82 }

83 static const bool kServiceIsNULLWhileTesting = true;

84

85 // Created lazily upon OnListenerAdded.

48 web::BrowserState* GetBrowserStateToUse(

49 web::BrowserState* context) const override;

50 bool ServiceIsNULLWhileTesting() const override;

51

52 DISALLOW_COPY_AND_ASSIGN(HistoryServiceFactory);

50 user_prefs::PrefRegistrySyncable* registry) override;

51 bool ServiceIsCreatedWithBrowserContext() const override;

52 bool ServiceIsNULLWhileTesting() const override;

53

54 DISALLOW_COPY_AND_ASSIGN(AutomaticProfileResetterFactory);

51 void OnPrefChanged(PrefService* pref_service, const std::string& pref_key);

52

53 static const bool kServiceIsNULLWhileTesting = true;

54 static const bool kServiceRedirectedInIncognito = false;

55

48 // test BrowserStates - these contexts will not create services for any

49 // BrowserStateKeyedBaseFactories that return true from

50 // ServiceIsNULLWhileTesting().

51 void CreateBrowserStateServicesForTest(web::BrowserState* context);

52

85 }

86

87 bool BookmarkModelFactory::ServiceIsNULLWhileTesting() const {

88 return true;

89 }

90 // SetTestingFactory() to make sure our contexts don't directly refer to the

91 // services they use.)

92 bool ServiceIsNULLWhileTesting() const override;

93

94 // Interface for people building a type of BrowserStateKeyedFactory: -------

30 virtual bool ServiceRedirectedInIncognito() const OVERRIDE;

31 virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;

32 virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;

33 };

34