Refactor loading out of ExtensionService.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/crx_installer.h"
+#include "chrome/browser/extensions/component_loader.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_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/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/unpacked_installer.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_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"
@@ skipping 530 matching lines @@
   // to happen, use loop_.RunAllPending();. Most tests will not use this
   // method directly.  Instead, use InstallCrx(), which waits for
   // the crx to be installed and does extra error checking.
   void StartCrxInstall(const FilePath& crx_path) {
     StartCrxInstall(crx_path, false);
   }
 
   void StartCrxInstall(const FilePath& crx_path, bool from_webstore) {
     ASSERT_TRUE(file_util::PathExists(crx_path))
         << "Path does not exist: "<< crx_path.value().c_str();
-    scoped_refptr<CrxInstaller> installer(
-        service_->MakeCrxInstaller(NULL));
+    scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(service_, NULL));
     installer->set_allow_silent_install(true);
     installer->set_is_gallery_install(from_webstore);
     installer->InstallCrx(crx_path);
   }
 
   void InstallCrx(const FilePath& path,
                         bool should_succeed) {
     StartCrxInstall(path);
     WaitForCrxInstall(path, should_succeed);
   }
 
   void InstallCrxWithLocation(const FilePath& crx_path,
                               Extension::Location install_location,
                               bool should_succeed) {
     ASSERT_TRUE(file_util::PathExists(crx_path))
         << "Path does not exist: "<< crx_path.value().c_str();
     // no client (silent install)
-    scoped_refptr<CrxInstaller> installer(service_->MakeCrxInstaller(NULL));
+    scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(service_, NULL));
 
     installer->set_install_source(install_location);
     installer->InstallCrx(crx_path);
 
     WaitForCrxInstall(crx_path, should_succeed);
   }
 
   // Wait for a CrxInstaller to finish. Used by InstallCrx.
   void WaitForCrxInstall(const FilePath& path,
                          bool should_succeed) {
@@ skipping 744 matching lines @@
 // Install a user script (they get converted automatically to an extension)
 TEST_F(ExtensionServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
   // integration with ExtensionService.
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_
              .AppendASCII("user_script_basic.user.js");
 
   ASSERT_TRUE(file_util::PathExists(path));
-  scoped_refptr<CrxInstaller> installer(
-      service_->MakeCrxInstaller(NULL));
+  scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(service_, NULL));
   installer->set_allow_silent_install(true);
   installer->InstallUserScript(
       path,
       GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
 
   loop_.RunAllPending();
   std::vector<std::string> errors = GetErrors();
   EXPECT_TRUE(installed_) << "Nothing was installed.";
   ASSERT_EQ(1u, loaded_.size()) << "Nothing was loaded.";
   EXPECT_EQ(0u, errors.size()) << "There were errors: "
@@ skipping 367 matching lines @@
   InstallCrx(path, false);
   ValidatePrefKeyCount(pref_count);
 }
 
 TEST_F(ExtensionServiceTest, LoadLocalizedTheme) {
   // Load.
   InitializeEmptyExtensionService();
   FilePath extension_path = data_dir_
       .AppendASCII("theme_i18n");
 
-  service_->LoadExtension(extension_path);
+  extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("name", service_->extensions()->at(0)->name());
   EXPECT_EQ("description", service_->extensions()->at(0)->description());
 }
 
 TEST_F(ExtensionServiceTest, InstallLocalizedTheme) {
   InitializeEmptyExtensionService();
@@ skipping 395 matching lines @@
   ASSERT_FALSE(file_util::PathExists(manifest_path));
 
   // Start with version 2.0.
   DictionaryValue manifest;
   manifest.SetString("version", "2.0");
   manifest.SetString("name", "LOAD Downgrade Test");
 
   JSONFileValueSerializer serializer(manifest_path);
   ASSERT_TRUE(serializer.Serialize(manifest));
 
-  service_->LoadExtension(extension_path);
+  extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
   loop_.RunAllPending();
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Extension::LOAD, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("2.0", loaded_[0]->VersionString());
 
   // Now set the version number to 1.0, reload the extensions and verify that
   // the downgrade was accepted.
   manifest.SetString("version", "1.0");
   ASSERT_TRUE(serializer.Serialize(manifest));
 
-  service_->LoadExtension(extension_path);
+  extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
   loop_.RunAllPending();
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Extension::LOAD, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("1.0", loaded_[0]->VersionString());
 }
 
 namespace {
@@ skipping 408 matching lines @@
 
   // Install a component extension.
   FilePath path = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good0)
       .AppendASCII("1.0.0.0");
   std::string manifest;
   ASSERT_TRUE(file_util::ReadFileToString(
       path.Append(Extension::kManifestFilename), &manifest));
-  service_->register_component_extension(
-      ExtensionService::ComponentExtensionInfo(manifest, path));
+  service_->component_loader()->Add(manifest, path);
   service_->Init();
 
   // Extension should be installed despite blacklist.
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(good0, service_->extensions()->at(0)->id());
 
   // Poke external providers and make sure the extension is still present.
   service_->CheckForExternalUpdates();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(good0, service_->extensions()->at(0)->id());
@@ skipping 430 matching lines @@
 
 // Tests loading single extensions (like --load-extension)
 TEST_F(ExtensionServiceTest, LoadExtension) {
   InitializeEmptyExtensionService();
 
   FilePath ext1 = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
-  service_->LoadExtension(ext1);
+  extensions::UnpackedInstaller::Create(service_)->Load(ext1);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Extension::LOAD, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
 
   ValidatePrefKeyCount(1);
 
   FilePath no_manifest = data_dir_
       .AppendASCII("bad")
       // .AppendASCII("Extensions")
       .AppendASCII("cccccccccccccccccccccccccccccccc")
       .AppendASCII("1");
-  service_->LoadExtension(no_manifest);
+  extensions::UnpackedInstaller::Create(service_)->Load(no_manifest);
   loop_.RunAllPending();
   EXPECT_EQ(1u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, service_->extensions()->size());
 
   // Test uninstall.
   std::string id = loaded_[0]->id();
   EXPECT_FALSE(unloaded_id_.length());
   service_->UninstallExtension(id, false, NULL);
   loop_.RunAllPending();
   EXPECT_EQ(id, unloaded_id_);
   ASSERT_EQ(0u, loaded_.size());
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
 // Tests that we generate IDs when they are not specified in the manifest for
 // --load-extension.
 TEST_F(ExtensionServiceTest, GenerateID) {
   InitializeEmptyExtensionService();
 
 
   FilePath no_id_ext = data_dir_.AppendASCII("no_id");
-  service_->LoadExtension(no_id_ext);
+  extensions::UnpackedInstaller::Create(service_)->Load(no_id_ext);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_TRUE(Extension::IdIsValid(loaded_[0]->id()));
   EXPECT_EQ(loaded_[0]->location(), Extension::LOAD);
 
   ValidatePrefKeyCount(1);
 
   std::string previous_id = loaded_[0]->id();
 
   // If we reload the same path, we should get the same extension ID.
-  service_->LoadExtension(no_id_ext);
+  extensions::UnpackedInstaller::Create(service_)->Load(no_id_ext);
   loop_.RunAllPending();
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(previous_id, loaded_[0]->id());
 }
 
 void ExtensionServiceTest::TestExternalProvider(
     MockExtensionProvider* provider, Extension::Location location) {
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
@@ skipping 108 matching lines @@
     loaded_.clear();
     service_->UninstallExtension(id, false, NULL);
     loop_.RunAllPending();
     ASSERT_EQ(0u, loaded_.size());
 
     // Then remove the extension from the extension provider.
     provider->RemoveExtension(good_crx);
 
     // Should still be at 0.
     loaded_.clear();
-    service_->LoadAllExtensions();
+    extensions::InstalledLoader(service_).LoadAllExtensions();
     loop_.RunAllPending();
     ASSERT_EQ(0u, loaded_.size());
     ValidatePrefKeyCount(1);
 
     EXPECT_EQ(5, provider->visit_count());
   } else {
     EXPECT_EQ(2, provider->visit_count());
   }
 }
 
@@ skipping 430 matching lines @@
       .AppendASCII("1.0");
 
   // The old permission name for unlimited quota was "unlimited_storage", but
   // we changed it to "unlimitedStorage". This tests both versions.
   FilePath unlimited_quota_ext =
       extensions_path.AppendASCII("unlimited_quota")
       .AppendASCII("1.0");
   FilePath unlimited_quota_ext2 =
       extensions_path.AppendASCII("unlimited_quota")
       .AppendASCII("2.0");
-  service_->LoadExtension(limited_quota_ext);
-  service_->LoadExtension(unlimited_quota_ext);
-  service_->LoadExtension(unlimited_quota_ext2);
+  extensions::UnpackedInstaller::Create(service_)->Load(limited_quota_ext);
+  extensions::UnpackedInstaller::Create(service_)->Load(unlimited_quota_ext);
+  extensions::UnpackedInstaller::Create(service_)->Load(unlimited_quota_ext2);
   loop_.RunAllPending();
 
   ASSERT_EQ(3u, loaded_.size());
   EXPECT_TRUE(profile_.get());
   EXPECT_FALSE(profile_->IsOffTheRecord());
   EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
       loaded_[0]->url()));
   EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
       loaded_[1]->url()));
   EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
       loaded_[2]->url()));
 }
 
-// Tests ExtensionService::register_component_extension().
+// Tests ComponentLoader::Add().
 TEST_F(ExtensionServiceTest, ComponentExtensions) {
   InitializeEmptyExtensionService();
 
   // Component extensions should work even when extensions are disabled.
   set_extensions_enabled(false);
 
   FilePath path = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::string manifest;
   ASSERT_TRUE(file_util::ReadFileToString(
       path.Append(Extension::kManifestFilename), &manifest));
 
-  service_->register_component_extension(
-      ExtensionService::ComponentExtensionInfo(manifest, path));
+  service_->component_loader()->Add(manifest, path);
   service_->Init();
 
   // Note that we do not pump messages -- the extension should be loaded
   // immediately.
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Extension::COMPONENT, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
 
-  // Component extensions shouldn't get recourded in the prefs.
+  // Component extensions shouldn't get recorded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }
 
@@ skipping 560 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }