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.

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

For background, maybe we should include a comment about why we took this
approach rather than just allowing the override of DeclareFactoryDependencies? 
(Specifically, this allows definitions for partial specializations, such as
those in ApiResourceManager<T>)

[Kevin M, 2017/05/15 18:34:39]

Done - added the explanation to the deprecated DeclareBrowserDependencies()
method. IMO once everything's migrated the explanation will become trivia noise.

[Devlin, 2017/05/15 18:37:47]

I dunno - I think it might help avoid a well-meaning developer trying to
simplify the code down the road (only to realize it won't compile). :)  For the
one line of comment code it adds, I'd leave it in.

[Kevin M, 2017/05/15 18:43:01]

Done.

+//   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());
-  //   }
+  // Declares dependencies on other factories.
+  // Deprecated. Use BrowserContextFactoryDependencies<> to declare
+  // dependencies instead.
   void DeclareFactoryDependencies() {
-    DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
+    BrowserContextFactoryDependencies<T>::DeclareFactoryDependencies(this);
   }
 
   BrowserContextKeyedAPIFactory()
       : BrowserContextKeyedServiceFactory(
             T::service_name(),
             BrowserContextDependencyManager::GetInstance()) {
     DeclareFactoryDependencies();
   }
 
   ~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_