ProcessManagerFactory: fix dependencies in ApiResourceManager, LazyBgndTaskFactory

extensions/browser/browser_context_keyed_api_factory.h

 // 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 EXTENSIONS_BROWSER_BROWSER_CONTEXT_KEYED_API_FACTORY_H_
 #define EXTENSIONS_BROWSER_BROWSER_CONTEXT_KEYED_API_FACTORY_H_
 
 #include "base/macros.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
@@ skipping 48 matching lines @@
   //   static base::LazyInstance<BrowserContextKeyedAPIFactory<HistoryAPI>>::
   //      DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
   //
   //   // static
   //   BrowserContextKeyedAPIFactory<HistoryAPI>*
   //   HistoryAPI::GetFactoryInstance() {
   //     return g_factory.Pointer();
   //   }
 };
 
+// Declare dependencies on other factories.
+// By default, ExtensionSystemFactory is the only dependency; however,
+// specializations can override this. Declare your specialization in
+// your header file after the BrowserContextKeyedAPI class definition.
+// Declare this struct in the header file. The implementation may optionally
+// be placed in your .cc file.
+//   template <>
+//   struct BrowserContextFactoryDependencies<MyService> {
+//     static void DeclareFactoryDependencies(
+//         BrowserContextKeyedAPIFactory<ApiResourceManager<T>>* factory) {
+//       factory->DependsOn(
+//           ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+//       factory->DependsOn(ProfileSyncServiceFactory::GetInstance());
+//       ...
+//     }
+//   };
+template <typename T>
+struct BrowserContextFactoryDependencies {
+  static void DeclareFactoryDependencies(
+      BrowserContextKeyedAPIFactory<T>* factory) {
+    factory->DependsOn(
+        ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+  }
+};
+
 // A template for factories for KeyedServices that manage extension APIs. T is
 // a KeyedService that uses this factory template instead of its own separate
 // factory definition to manage its per-profile instances.
 template <typename T>
 class BrowserContextKeyedAPIFactory : public BrowserContextKeyedServiceFactory {
  public:
   static T* Get(content::BrowserContext* context) {
     return static_cast<T*>(
         T::GetFactoryInstance()->GetServiceForBrowserContext(context, true));
   }
 
   static T* GetIfExists(content::BrowserContext* context) {
     return static_cast<T*>(
         T::GetFactoryInstance()->GetServiceForBrowserContext(context, false));
   }
 
-  // Declare dependencies on other factories.
-  // By default, ExtensionSystemFactory is the only dependency; however,
-  // specializations can override this. Declare your specialization in
-  // your header file after the BrowserContextKeyedAPI class definition.
-  // Then in the cc file (or inline in the header), define it, e.g.:
-  //   template <>
-  //   void BrowserContextKeyedAPIFactory<
-  //       PushMessagingAPI>::DeclareFactoryDependencies() {
-  //     DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
-  //     DependsOn(ProfileSyncServiceFactory::GetInstance());
-  //   }
-  void DeclareFactoryDependencies() {
-    DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
-  }
+  // Declares dependencies on other factories.
+  // Deprecated. Use BrowserContextFactoryDependencies<> to declare
+  // dependencies instead.
+  void DeclareFactoryDependencies() {}
 
   BrowserContextKeyedAPIFactory()
       : BrowserContextKeyedServiceFactory(
             T::service_name(),
             BrowserContextDependencyManager::GetInstance()) {
     DeclareFactoryDependencies();
+    BrowserContextFactoryDependencies<T>::DeclareFactoryDependencies(this);

[Devlin, 2017/05/12 22:53:59]

Hmm... wouldn't doing this result in ExtensionSystemFactory getting added
multiple times for all current overrides?  Once in DeclareFactoryDepenencies
specialization, and once in the BrowserContextFactoryDependencies helper?

[Kevin M, 2017/05/15 18:09:04]

Hm, yes. Thanks. How's this for backwards compatibility?

A) If subclasses implement DeclareFactoryDependencies: only
DeclareFactoryDependencies() is called.

B) If subclasses implement BrowserContextFactoryDependencies<>: only
BrowserContextFactoryDependencies<> is called.

C) If subclasses implement A and B: only DeclareFactoryDependencies() is called.

[Devlin, 2017/05/15 18:24:52]

SGTM; that should work!

   }
 
   ~BrowserContextKeyedAPIFactory() override {}
 
  private:
+  friend struct BrowserContextFactoryDependencies<T>;
+
   // BrowserContextKeyedServiceFactory implementation.
   KeyedService* BuildServiceInstanceFor(
       content::BrowserContext* context) const override {
     return new T(context);
   }
 
   // BrowserContextKeyedBaseFactory implementation.
   // These can be effectively overridden with template specializations.
   content::BrowserContext* GetBrowserContextToUse(
       content::BrowserContext* context) const override {
@@ skipping 13 matching lines @@
   bool ServiceIsNULLWhileTesting() const override {
     return T::kServiceIsNULLWhileTesting;
   }
 
   DISALLOW_COPY_AND_ASSIGN(BrowserContextKeyedAPIFactory);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_BROWSER_CONTEXT_KEYED_API_FACTORY_H_