Take extensions out of Profile into a profile-keyed service, ExtensionSystem.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2012 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_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 15 matching lines @@
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider_impl.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/external_pref_extension_loader.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pack_extension_job.cc"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
+#include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/plugin_prefs_factory.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/sync/protocol/app_specifics.pb.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/string_ordinal.h"
 #include "chrome/common/url_constants.h"
@@ skipping 296 matching lines @@
 
  private:
   int ids_found_;
   FilePath fake_base_path_;
   scoped_ptr<ExternalExtensionProviderImpl> provider_;
   scoped_ptr<DictionaryValue> prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
-class ExtensionTestingProfile : public TestingProfile {
- public:
-  ExtensionTestingProfile() : service_(NULL) {
-  }
-
-  void set_extensions_service(ExtensionService* service) {
-    service_ = service;
-  }
-  virtual ExtensionService* GetExtensionService() { return service_; }
-
- private:
-  ExtensionService* service_;
-};
-
 // Our message loop may be used in tests which require it to be an IO loop.
 ExtensionServiceTestBase::ExtensionServiceTestBase()
     : loop_(MessageLoop::TYPE_IO),
       service_(NULL),
       expected_extensions_count_(0),
       ui_thread_(BrowserThread::UI, &loop_),
       db_thread_(BrowserThread::DB, &loop_),
       webkit_thread_(BrowserThread::WEBKIT_DEPRECATED, &loop_),
       file_thread_(BrowserThread::FILE, &loop_),
       file_user_blocking_thread_(BrowserThread::FILE_USER_BLOCKING, &loop_),
@@ skipping 12 matching lines @@
   // (they are used in the destruction process).
   service_ = NULL;
   MessageLoop::current()->RunAllPending();
   profile_.reset(NULL);
   MessageLoop::current()->RunAllPending();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionService(
     const FilePath& pref_file, const FilePath& extensions_install_dir,
     bool autoupdate_enabled) {
-  ExtensionTestingProfile* profile = new ExtensionTestingProfile();
+  TestingProfile* profile = new TestingProfile();
   // Create a PrefService that only contains user defined preference values.
   PrefService* prefs =
       PrefServiceMockBuilder().WithUserFilePrefs(pref_file).Create();
   Profile::RegisterUserPrefs(prefs);
   browser::RegisterUserPrefs(prefs);
   profile->SetPrefService(prefs);
 
   PluginPrefsFactory::GetInstance()->ForceRegisterPrefsForTest(prefs);
 
   profile_.reset(profile);
 
-  service_ = profile->CreateExtensionService(
-      CommandLine::ForCurrentProcess(),
-      extensions_install_dir,
-      autoupdate_enabled);
+  service_ = static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile))->CreateExtensionService(
+          CommandLine::ForCurrentProcess(),
+          extensions_install_dir,
+          autoupdate_enabled);
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
-  profile->set_extensions_service(service_);
 
   // 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();
 
   expected_extensions_count_ = 0;
 }
@@ skipping 13 matching lines @@
   file_util::CopyDirectory(source_install_dir, extensions_install_dir_, true);
 
   InitializeExtensionService(temp_prefs, extensions_install_dir_, false);
 }
 
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
   InitializeExtensionServiceHelper(false);
 }
 
 void ExtensionServiceTestBase::InitializeExtensionProcessManager() {
-  profile_->CreateExtensionProcessManager();
+  static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile_.get()))->
+      CreateExtensionProcessManager();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
   InitializeExtensionServiceHelper(true);
   service_->updater()->Start();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceHelper(
     bool autoupdate_enabled) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path_ = temp_dir_.path();
   path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   file_util::Delete(path_, true);
   file_util::CreateDirectory(path_);
   FilePath prefs_filename = path_
       .Append(FILE_PATH_LITERAL("TestPreferences"));
   extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
   file_util::Delete(extensions_install_dir_, true);
   file_util::CreateDirectory(extensions_install_dir_);
 
   InitializeExtensionService(prefs_filename, extensions_install_dir_,
                              autoupdate_enabled);
 }
 
 void ExtensionServiceTestBase::InitializeRequestContext() {
   ASSERT_TRUE(profile_.get());
-  ExtensionTestingProfile* profile =
-      static_cast<ExtensionTestingProfile*>(profile_.get());
+  TestingProfile* profile =
+      static_cast<TestingProfile*>(profile_.get());
   profile->CreateRequestContext();
 }
 
 // static
 void ExtensionServiceTestBase::SetUpTestCase() {
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
@@ skipping 226 matching lines @@
       int expected_installed_extension_count =
           (expected_state >= INSTALLED) ? 1 : 0;
       int expected_enabled_extension_count =
           (expected_state >= ENABLED) ? 1 : 0;
       EXPECT_EQ(expected_installed_extension_count,
                 installed_extension_count);
       EXPECT_EQ(expected_enabled_extension_count,
                 enabled_extension_count);
     }
 
-    // Update() should delete the temporary input file.
+    // Update() should the temporary input file.
     EXPECT_FALSE(file_util::PathExists(path));
   }
 
   void TerminateExtension(const std::string& id) {
     const Extension* extension = service_->GetInstalledExtension(id);
     if (!extension) {
       ADD_FAILURE();
       return;
     }
     service_->TrackTerminatedExtensionForTest(extension);
@@ skipping 3061 matching lines @@
   content::TestBrowserThread ui_thread(BrowserThread::UI, &loop);
   content::TestBrowserThread file_thread(BrowserThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
   FilePath install_dir = profile->GetPath()
       .AppendASCII(ExtensionService::kInstallDirectoryName);
   webkit::npapi::MockPluginList plugin_list(NULL, 0);
   PluginService::GetInstance()->SetPluginListForTesting(&plugin_list);
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
-  // Owned by |profile|.
-  ExtensionService* service =
-      profile->CreateExtensionService(command_line.get(),
-                                      install_dir,
-                                      false);
+  ExtensionService* service = static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile.get()))->
+      CreateExtensionService(
+          command_line.get(),
+          install_dir,
+          false);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // If either the command line or pref is set, we are disabled.
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   command_line->AppendSwitch(switches::kDisableExtensions);
-  service = profile->CreateExtensionService(command_line.get(),
-                                            install_dir,
-                                            false);
+  service = static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile.get()))->
+      CreateExtensionService(
+          command_line.get(),
+          install_dir,
+          false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
-  service = profile->CreateExtensionService(command_line.get(),
-                                            install_dir,
-                                            false);
+  service = static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile.get()))->
+      CreateExtensionService(
+          command_line.get(),
+          install_dir,
+          false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
-  service = profile->CreateExtensionService(command_line.get(),
-                                            install_dir,
-                                            false);
+  service = static_cast<TestExtensionSystem*>(
+      ExtensionSystemFactory::GetForProfile(profile.get()))->
+      CreateExtensionService(
+          command_line.get(),
+          install_dir,
+          false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // Explicitly delete all the resources used in this test.
   profile.reset();
   service = NULL;
 }
 
@@ skipping 911 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, INSTALL_NEW);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }