Extract a MockExtensionSystem to be used with TestExtensionsBrowserClient.

The default implementation provides no subservices. Its purpose is to fulfill a dependency (in unit tests)
when other BrowserContextKeyedServices depend on an ExtensionSystem. Tests that actually need subservices
can override the necessary methods to provide them.

Also, this defines a MockExtensionSystemFactory template for ease of use with MockExtensionSystem subclasses.

BUG=348066

Review URL: https://codereview.chromium.org/460203002

Cr-Commit-Position: refs/heads/master@{#289235}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289235 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/extensions/menu_manager_unittest.cc

@@ -453,6 +453,8 @@ TEST_F(MenuManagerTest, ExtensionUnloadRemovesMenuItems) {
   ASSERT_TRUE(manager_.GetItemById(item2->id()) != NULL);
 }
 
+namespace {
+
 // A mock message service for tests of MenuManager::ExecuteCommand.
 class MockEventRouter : public EventRouter {
  public:
@@ -502,6 +504,8 @@ KeyedService* BuildMockExtensionSystem(content::BrowserContext* profile) {
   return new MockExtensionSystem(static_cast<Profile*>(profile));
 }
 
+}  // namespace
+
 // Tests the RemoveAll functionality.
 TEST_F(MenuManagerTest, RemoveAll) {
   // Try removing all items for an extension id that doesn't have any items.

extensions/browser/lazy_background_task_queue_unittest.cc

@@ -13,11 +13,11 @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_test.h"
+#include "extensions/browser/mock_extension_system.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/test_extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
-#include "extensions/common/one_shot_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
@@ -53,70 +53,18 @@ class TestProcessManager : public ProcessManager {
 };
 
 // A simple ExtensionSystem that returns a TestProcessManager.
-class MockExtensionSystem : public ExtensionSystem {
+class MockExtensionSystemWithProcessManager : public MockExtensionSystem {
  public:
-  explicit MockExtensionSystem(BrowserContext* context)
-      : test_process_manager_(context) {}
-  virtual ~MockExtensionSystem() {}
-
-  virtual void InitForRegularProfile(bool extensions_enabled) OVERRIDE {}
-  virtual ExtensionService* extension_service() OVERRIDE { return NULL; }
-  virtual RuntimeData* runtime_data() OVERRIDE { return NULL; }
-  virtual ManagementPolicy* management_policy() OVERRIDE { return NULL; }
-  virtual UserScriptMaster* user_script_master() OVERRIDE { return NULL; }
+  explicit MockExtensionSystemWithProcessManager(BrowserContext* context)
+      : MockExtensionSystem(context), test_process_manager_(context) {}
+  virtual ~MockExtensionSystemWithProcessManager() {}
+
   virtual ProcessManager* process_manager() OVERRIDE {
     return &test_process_manager_;
   }
-  virtual StateStore* state_store() OVERRIDE { return NULL; }
-  virtual StateStore* rules_store() OVERRIDE { return NULL; }
-  virtual InfoMap* info_map() OVERRIDE { return NULL; }
-  virtual LazyBackgroundTaskQueue* lazy_background_task_queue() OVERRIDE {
-    return NULL;
-  }
-  virtual EventRouter* event_router() OVERRIDE { return NULL; }
-  virtual ExtensionWarningService* warning_service() OVERRIDE { return NULL; }
-  virtual Blacklist* blacklist() OVERRIDE { return NULL; }
-  virtual ErrorConsole* error_console() OVERRIDE { return NULL; }
-  virtual InstallVerifier* install_verifier() OVERRIDE { return NULL; }
-  virtual QuotaService* quota_service() OVERRIDE { return NULL; }
-  virtual const OneShotEvent& ready() const OVERRIDE { return ready_; }
-  virtual ContentVerifier* content_verifier() OVERRIDE { return NULL; }
-  virtual scoped_ptr<ExtensionSet> GetDependentExtensions(
-      const Extension* extension) OVERRIDE {
-    return scoped_ptr<ExtensionSet>();
-  }
 
  private:
   TestProcessManager test_process_manager_;
-  OneShotEvent ready_;
-};
-
-// A factory to create a MockExtensionSystem.
-class MockExtensionSystemFactory : public ExtensionSystemProvider {
- public:
-  MockExtensionSystemFactory()
-      : ExtensionSystemProvider(
-            "MockExtensionSystem",
-            BrowserContextDependencyManager::GetInstance()) {
-    DependsOn(ExtensionRegistryFactory::GetInstance());
-  }
-  virtual ~MockExtensionSystemFactory() {}
-
-  // BrowserContextKeyedServiceFactory overrides:
-  virtual KeyedService* BuildServiceInstanceFor(
-      BrowserContext* context) const OVERRIDE {
-    return new MockExtensionSystem(context);
-  }
-
-  // ExtensionSystemProvider overrides:
-  virtual ExtensionSystem* GetForBrowserContext(
-      BrowserContext* context) OVERRIDE {
-    return static_cast<MockExtensionSystem*>(
-        GetServiceForBrowserContext(context, true));
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockExtensionSystemFactory);
 };
 
 }  // namespace
@@ -172,7 +120,8 @@ class LazyBackgroundTaskQueueTest : public ExtensionsTest {
 
  private:
   scoped_ptr<content::NotificationService> notification_service_;
-  MockExtensionSystemFactory extension_system_factory_;
+  MockExtensionSystemFactory<MockExtensionSystemWithProcessManager>
+      extension_system_factory_;
 
   // The total number of pending tasks that have been executed.
   int task_run_count_;

extensions/browser/mock_extension_system.cc

+// 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.
+
+#include "extensions/browser/mock_extension_system.h"
+
+#include "extensions/common/extension_set.h"
+
+namespace extensions {
+
+//
+// MockExtensionSystem
+//
+
+MockExtensionSystem::MockExtensionSystem(content::BrowserContext* context)
+    : browser_context_(context) {
+}
+
+MockExtensionSystem::~MockExtensionSystem() {
+}
+
+void MockExtensionSystem::InitForRegularProfile(bool extensions_enabled) {
+}
+
+ExtensionService* MockExtensionSystem::extension_service() {
+  return NULL;
+}
+
+RuntimeData* MockExtensionSystem::runtime_data() {
+  return NULL;
+}
+
+ManagementPolicy* MockExtensionSystem::management_policy() {
+  return NULL;
+}
+
+UserScriptMaster* MockExtensionSystem::user_script_master() {
+  return NULL;
+}
+
+ProcessManager* MockExtensionSystem::process_manager() {
+  return NULL;
+}
+
+StateStore* MockExtensionSystem::state_store() {
+  return NULL;
+}
+
+StateStore* MockExtensionSystem::rules_store() {
+  return NULL;
+}
+
+InfoMap* MockExtensionSystem::info_map() {
+  return NULL;
+}
+
+LazyBackgroundTaskQueue* MockExtensionSystem::lazy_background_task_queue() {
+  return NULL;
+}
+
+EventRouter* MockExtensionSystem::event_router() {
+  return NULL;
+}
+
+ExtensionWarningService* MockExtensionSystem::warning_service() {
+  return NULL;
+}
+
+Blacklist* MockExtensionSystem::blacklist() {
+  return NULL;
+}
+
+ErrorConsole* MockExtensionSystem::error_console() {
+  return NULL;
+}
+
+InstallVerifier* MockExtensionSystem::install_verifier() {
+  return NULL;
+}
+
+QuotaService* MockExtensionSystem::quota_service() {
+  return NULL;
+}
+
+const OneShotEvent& MockExtensionSystem::ready() const {
+  return ready_;
+}
+
+ContentVerifier* MockExtensionSystem::content_verifier() {
+  return NULL;
+}
+
+scoped_ptr<ExtensionSet> MockExtensionSystem::GetDependentExtensions(
+    const Extension* extension) {
+  return scoped_ptr<ExtensionSet>();
+}
+
+}  // namespace extensions

extensions/browser/mock_extension_system.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_MOCK_EXTENSIONS_SYSTEM_H_
+#define EXTENSIONS_BROWSER_MOCK_EXTENSIONS_SYSTEM_H_
+
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "extensions/browser/extension_registry_factory.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/extension_system_provider.h"
+#include "extensions/common/one_shot_event.h"
+
+namespace extensions {
+
+// An empty ExtensionSystem for testing. Tests that need only specific
+// parts of ExtensionSystem should derive from this class and override
+// functions as needed. To use this, use
+// TestExtensionsBrowserClient::set_extension_system_factory
+// with the MockExtensionSystemFactory below.
+class MockExtensionSystem : public ExtensionSystem {
+ public:
+  explicit MockExtensionSystem(content::BrowserContext* context);
+  virtual ~MockExtensionSystem();
+
+  content::BrowserContext* browser_context() { return browser_context_; }
+
+  // ExtensionSystem overrides:
+  virtual void InitForRegularProfile(bool extensions_enabled) OVERRIDE;
+  virtual ExtensionService* extension_service() OVERRIDE;
+  virtual RuntimeData* runtime_data() OVERRIDE;
+  virtual ManagementPolicy* management_policy() OVERRIDE;
+  virtual UserScriptMaster* user_script_master() OVERRIDE;
+  virtual ProcessManager* process_manager() OVERRIDE;
+  virtual StateStore* state_store() OVERRIDE;
+  virtual StateStore* rules_store() OVERRIDE;
+  virtual InfoMap* info_map() OVERRIDE;
+  virtual LazyBackgroundTaskQueue* lazy_background_task_queue() OVERRIDE;
+  virtual EventRouter* event_router() OVERRIDE;
+  virtual ExtensionWarningService* warning_service() OVERRIDE;
+  virtual Blacklist* blacklist() OVERRIDE;
+  virtual ErrorConsole* error_console() OVERRIDE;
+  virtual InstallVerifier* install_verifier() OVERRIDE;
+  virtual QuotaService* quota_service() OVERRIDE;
+  virtual const OneShotEvent& ready() const OVERRIDE;
+  virtual ContentVerifier* content_verifier() OVERRIDE;
+  virtual scoped_ptr<ExtensionSet> GetDependentExtensions(
+      const Extension* extension) OVERRIDE;
+
+ private:
+  content::BrowserContext* browser_context_;
+  OneShotEvent ready_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockExtensionSystem);
+};
+
+// A factory to create a MockExtensionSystem. Sample use:
+//
+// MockExtensionSystemFactory<MockExtensionSystemSubclass> factory;
+// TestExtensionsBrowserClient::set_extension_system_factory(factory);
+template <typename T>
+class MockExtensionSystemFactory : public ExtensionSystemProvider {
+ public:
+  MockExtensionSystemFactory()
+      : ExtensionSystemProvider(
+            "MockExtensionSystem",
+            BrowserContextDependencyManager::GetInstance()) {
+    DependsOn(ExtensionRegistryFactory::GetInstance());
+  }
+
+  virtual ~MockExtensionSystemFactory() {}
+
+  // BrowserContextKeyedServiceFactory overrides:
+  virtual KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const OVERRIDE {
+    return new T(context);
+  }
+
+  // ExtensionSystemProvider overrides:
+  virtual ExtensionSystem* GetForBrowserContext(
+      content::BrowserContext* context) OVERRIDE {
+    return static_cast<ExtensionSystem*>(
+        GetServiceForBrowserContext(context, true));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockExtensionSystemFactory);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_MOCK_EXTENSIONS_SYSTEM_H_

extensions/extensions.gyp

@@ -739,6 +739,8 @@
         'browser/api_test_utils.h',
         'browser/extensions_test.cc',
         'browser/extensions_test.h',
+        'browser/mock_extension_system.cc',
+        'browser/mock_extension_system.h',
         'browser/test_extensions_browser_client.cc',
         'browser/test_extensions_browser_client.h',
         'browser/test_management_policy.cc',