Move ExtensionServiceTestBase into it's own header/cc file

chrome/browser/extensions/extension_service_test_base.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 "chrome/browser/extensions/extension_service_test_base.h"
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
+#include "chrome/browser/extensions/extension_error_reporter.h"
+#include "chrome/browser/extensions/extension_garbage_collector_factory.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/browser/extensions/updater/extension_updater.h"
+#include "chrome/browser/prefs/browser_prefs.h"
+#include "chrome/browser/prefs/pref_service_mock_factory.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/browser/browser_context.h"
+#include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/extensions/install_limiter.h"
+#endif
+
+namespace extensions {
+
+namespace {
+
+// Create a testing profile according to |params|.
+scoped_ptr<TestingProfile> BuildTestingProfile(
+    const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
+  TestingProfile::Builder profile_builder;
+  // Create a PrefService that only contains user defined preference values.
+  PrefServiceMockFactory factory;
+  // If pref_file is empty, TestingProfile automatically creates
+  // TestingPrefServiceSyncable instance.
+  if (!params.pref_file.empty()) {
+    factory.SetUserPrefsFile(params.pref_file,
+                             base::MessageLoopProxy::current().get());
+    scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
+        new user_prefs::PrefRegistrySyncable);
+    scoped_ptr<PrefServiceSyncable> prefs(
+        factory.CreateSyncable(registry.get()));
+    chrome::RegisterUserProfilePrefs(registry.get());
+    profile_builder.SetPrefService(prefs.Pass());
+  }
+
+  if (params.profile_is_managed)
+    profile_builder.SetManagedUserId("asdf");
+
+  profile_builder.SetPath(params.profile_path);
+  return profile_builder.Build();
+}
+
+}  // namespace
+
+ExtensionServiceTestBase::ExtensionServiceInitParams::
+    ExtensionServiceInitParams()
+    : autoupdate_enabled(false), is_first_run(true), profile_is_managed(false) {
+}
+
+// Our message loop may be used in tests which require it to be an IO loop.
+ExtensionServiceTestBase::ExtensionServiceTestBase()
+    : service_(NULL),
+      thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+      registry_(NULL) {
+  base::FilePath test_data_dir;
+  if (!PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir)) {
+    ADD_FAILURE();
+    return;
+  }
+  data_dir_ = test_data_dir.AppendASCII("extensions");
+}
+
+ExtensionServiceTestBase::~ExtensionServiceTestBase() {
+  // Why? Because |profile_| has to be destroyed before |at_exit_manager_|, but
+  // is declared above it in the class definition since it's protected.
+  profile_.reset();
+}
+
+ExtensionServiceTestBase::ExtensionServiceInitParams
+ExtensionServiceTestBase::CreateDefaultInitParams() {
+  ExtensionServiceInitParams params;
+  EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+  base::FilePath path = temp_dir_.path();
+  path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
+  EXPECT_TRUE(base::DeleteFile(path, true));
+  base::File::Error error = base::File::FILE_OK;
+  EXPECT_TRUE(base::CreateDirectoryAndGetError(path, &error)) << error;
+  base::FilePath prefs_filename =
+      path.Append(FILE_PATH_LITERAL("TestPreferences"));
+  base::FilePath extensions_install_dir =
+      path.Append(FILE_PATH_LITERAL("Extensions"));
+  EXPECT_TRUE(base::DeleteFile(extensions_install_dir, true));
+  EXPECT_TRUE(base::CreateDirectoryAndGetError(extensions_install_dir, &error))
+      << error;
+
+  params.profile_path = path;
+  params.pref_file = prefs_filename;
+  params.extensions_install_dir = extensions_install_dir;
+  return params;
+}
+
+void ExtensionServiceTestBase::InitializeExtensionService(
+    const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
+  profile_ = BuildTestingProfile(params);
+  CreateExtensionService(params);
+
+  extensions_install_dir_ = params.extensions_install_dir;
+  registry_ = ExtensionRegistry::Get(profile_.get());
+
+  // Garbage collector is typically NULL during tests, so give it a build.
+  ExtensionGarbageCollectorFactory::GetInstance()->SetTestingFactoryAndUse(
+      profile_.get(), &ExtensionGarbageCollectorFactory::BuildInstanceFor);
+}
+
+void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
+  InitializeExtensionService(CreateDefaultInitParams());
+}
+
+void ExtensionServiceTestBase::InitializeInstalledExtensionService(
+    const base::FilePath& prefs_file,
+    const base::FilePath& source_install_dir) {
+  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  base::FilePath path = temp_dir_.path();
+
+  path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
+  ASSERT_TRUE(base::DeleteFile(path, true));
+
+  base::File::Error error = base::File::FILE_OK;
+  ASSERT_TRUE(base::CreateDirectoryAndGetError(path, &error)) << error;
+
+  base::FilePath temp_prefs = path.Append(chrome::kPreferencesFilename);
+  ASSERT_TRUE(base::CopyFile(prefs_file, temp_prefs));
+
+  base::FilePath extensions_install_dir =
+      path.Append(FILE_PATH_LITERAL("Extensions"));
+  ASSERT_TRUE(base::DeleteFile(extensions_install_dir, true));
+  ASSERT_TRUE(
+      base::CopyDirectory(source_install_dir, extensions_install_dir, true));
+
+  ExtensionServiceInitParams params;
+  params.profile_path = path;
+  params.pref_file = temp_prefs;
+  params.extensions_install_dir = extensions_install_dir;
+  InitializeExtensionService(params);
+}
+
+void ExtensionServiceTestBase::InitializeGoodInstalledExtensionService() {
+  base::FilePath source_install_dir =
+      data_dir_.AppendASCII("good").AppendASCII("Extensions");
+  base::FilePath pref_path =
+      source_install_dir.DirName().Append(chrome::kPreferencesFilename);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
+}
+
+void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.autoupdate_enabled = true;
+  InitializeExtensionService(params);
+  service_->updater()->Start();
+}
+
+void ExtensionServiceTestBase::InitializeProcessManager() {
+  static_cast<extensions::TestExtensionSystem*>(
+      ExtensionSystem::Get(profile_.get()))->CreateProcessManager();
+}
+
+void ExtensionServiceTestBase::SetUp() {
+  ExtensionErrorReporter::GetInstance()->ClearErrors();
+}
+
+void ExtensionServiceTestBase::SetUpTestCase() {
+  // Safe to call multiple times.
+  ExtensionErrorReporter::Init(false);  // no noisy errors.
+}
+
+// These are declared in the .cc so that all inheritors don't need to know
+// that TestingProfile derives Profile derives BrowserContext.
+content::BrowserContext* ExtensionServiceTestBase::browser_context() {
+  return profile_.get();
+}

[Yoyo Zhou, 2014/06/11 02:13:50]

nit: newline

[Devlin, 2014/06/11 15:44:16]

Done.

+Profile* ExtensionServiceTestBase::profile() {
+  return profile_.get();
+}
+
+void ExtensionServiceTestBase::CreateExtensionService(
+    const ExtensionServiceInitParams& params) {
+  TestExtensionSystem* system =
+      static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile_.get()));
+  if (!params.is_first_run) {
+    ExtensionPrefs* prefs = system->CreateExtensionPrefs(
+        base::CommandLine::ForCurrentProcess(), params.extensions_install_dir);
+    prefs->SetAlertSystemFirstRun();
+  }
+
+  service_ =
+      system->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
+                                     params.extensions_install_dir,
+                                     params.autoupdate_enabled);
+
+  service_->SetFileTaskRunnerForTesting(
+      base::MessageLoopProxy::current().get());
+  service_->set_extensions_enabled(true);
+  service_->set_show_extensions_prompts(false);
+  service_->set_install_updates_when_idle_for_test(false);
+
+  // When we start up, we want to make sure there is no external provider,
+  // since the ExtensionService on Windows will use the Registry as a default
+  // provider and if there is something already registered there then it will
+  // interfere with the tests. Those tests that need an external provider
+  // will register one specifically.
+  service_->ClearProvidersForTesting();
+
+#if defined(OS_CHROMEOS)
+  InstallLimiter::Get(profile_.get())->DisableForTest();
+#endif
+}
+
+}  // namespace extensions