Make ExtensionPrefs paths relative, re-enable 2 ExtensionsService unit_tests

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2009 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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 184 matching lines @@
  public:
   ExtensionsServiceTest() : installed_(NULL) {
     registrar_.Add(this, NotificationType::EXTENSIONS_LOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_INSTALLED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::THEME_INSTALLED,
                    NotificationService::AllSources());
+  }
 
+  virtual void InitializeExtensionsService(const FilePath& pref_file,
+      const FilePath& extensions_install_dir) {
+    prefs_.reset(new PrefService(pref_file, NULL));
     profile_.reset(new TestingProfile());
-    service_ = new ExtensionsService(
-        profile_.get(), CommandLine::ForCurrentProcess(), &loop_, &loop_);
+    service_ = new ExtensionsService(profile_.get(),
+                                     CommandLine::ForCurrentProcess(),
+                                     prefs_.get(),
+                                     extensions_install_dir,
+                                     &loop_,
+                                     &loop_);
     service_->SetExtensionsEnabled(true);
     service_->set_show_extensions_prompts(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();
 
     total_successes_ = 0;
   }
 
+  virtual void InitializeInstalledExtensionsService(const FilePath& prefs_file,
+      const FilePath& source_install_dir) {
+    FilePath path_;
+    ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &path_));
+    path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
+    file_util::Delete(path_, true);
+    file_util::CreateDirectory(path_);
+    FilePath temp_prefs = path_.Append(FILE_PATH_LITERAL("Preferences"));
+    file_util::CopyFile(prefs_file, temp_prefs);
+
+    extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
+    file_util::Delete(extensions_install_dir_, true);
+    file_util::CopyDirectory(source_install_dir, extensions_install_dir_, true);
+
+    InitializeExtensionsService(temp_prefs, extensions_install_dir_);
+  }
+
+  virtual void InitializeEmptyExtensionsService() {
+    FilePath path_;
+    ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &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_);
+
+    InitializeExtensionsService(prefs_filename, extensions_install_dir_);
+  }
+
   static void SetUpTestCase() {
     ExtensionErrorReporter::Init(false);  // no noisy errors
   }
 
   virtual void SetUp() {
     ExtensionErrorReporter::GetInstance()->ClearErrors();
   }
 
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
@@ skipping 129 matching lines @@
         EXPECT_EQ(1u, errors.size()) << path.value();
       }
       if (use_callback) {
         EXPECT_EQ(NULL, callback_recorder.extension());
       }
     }
   }
 
   void ValidatePrefKeyCount(size_t count) {
     DictionaryValue* dict =
-        profile_->GetPrefs()->GetMutableDictionary(L"extensions.settings");
+        prefs_->GetMutableDictionary(L"extensions.settings");
     ASSERT_TRUE(dict != NULL);
     EXPECT_EQ(count, dict->GetSize());
   }
 
   void ValidatePref(std::string extension_id,
                     std::wstring pref_path,
                     int must_equal) {
     std::wstring msg = L" while checking: ";
     msg += ASCIIToWide(extension_id);
     msg += L" ";
     msg += pref_path;
     msg += L" == ";
     msg += IntToWString(must_equal);
 
     const DictionaryValue* dict =
-        profile_->GetPrefs()->GetDictionary(L"extensions.settings");
+        prefs_->GetDictionary(L"extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(ASCIIToWide(extension_id), &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     int val;
     pref->GetInteger(pref_path, &val);
     EXPECT_EQ(must_equal, val) << msg;
   }
 
   void SetPref(std::string extension_id, std::wstring pref_path, int value) {
     std::wstring msg = L" while setting: ";
     msg += ASCIIToWide(extension_id);
     msg += L" ";
     msg += pref_path;
     msg += L" = ";
     msg += IntToWString(value);
 
     const DictionaryValue* dict =
-        profile_->GetPrefs()->GetMutableDictionary(L"extensions.settings");
+        prefs_->GetMutableDictionary(L"extensions.settings");
     ASSERT_TRUE(dict != NULL) << msg;
     DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(ASCIIToWide(extension_id), &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     pref->SetInteger(pref_path, value);
   }
 
  protected:
-  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<PrefService> prefs_;
+  scoped_ptr<Profile> profile_;
+  FilePath extensions_install_dir_;
   scoped_refptr<ExtensionsService> service_;
   size_t total_successes_;
   MessageLoop loop_;
   ExtensionList loaded_;
   std::string unloaded_id_;
   Extension* installed_;
 
  private:
   NotificationRegistrar registrar_;
 };
 
-// TODO(erikkay) this test and the next need to be replaced with equivalent
-// versions that load from prefs.
+FilePath::StringType NormalizeSeperators(FilePath::StringType path) {
+#if defined(FILE_PATH_USES_WIN_SEPARATORS)
+  FilePath::StringType ret_val;
+  for (size_t i = 0; i < path.length(); i++) {
+    if (FilePath::IsSeparator(path[i]))
+      path[i] = FilePath::kSeparators[0];
+  }
+#endif  // FILE_PATH_USES_WIN_SEPARATORS
+  return path;
+}
 // Test loading good extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, DISABLED_LoadAllExtensionsFromDirectorySuccess) {
-  // Copy the test extensions into the test profile.
-  FilePath source_path;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_path));
-  source_path = source_path.AppendASCII("extensions");
-  source_path = source_path.AppendASCII("good");
-
-  FilePath dest_path = profile_->GetPath().AppendASCII("Extensions");
-  file_util::CopyDirectory(source_path, dest_path, true);  // Recursive.
+TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectorySuccess) {
+  // Initialize the test dir with a good Preferences/extensions.
+  FilePath source_install_dir;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
+  source_install_dir = source_install_dir
+      .AppendASCII("extensions")
+      .AppendASCII("good")
+      .AppendASCII("Extensions");
+  FilePath pref_path = source_install_dir
+      .DirName()
+      .AppendASCII("Preferences");
+  InitializeInstalledExtensionsService(pref_path, source_install_dir);
 
   service_->Init();
   loop_.RunAllPending();
 
   std::vector<std::string> errors = GetErrors();
   for (std::vector<std::string>::iterator err = errors.begin();
     err != errors.end(); ++err) {
     LOG(ERROR) << *err;
   }
   ASSERT_EQ(3u, loaded_.size());
@@ skipping 18 matching lines @@
   Extension* extension = loaded_[0];
   const UserScriptList& scripts = extension->content_scripts();
   const std::vector<std::string>& toolstrips = extension->toolstrips();
   ASSERT_EQ(2u, scripts.size());
   EXPECT_EQ(2u, scripts[0].url_patterns().size());
   EXPECT_EQ("http://*.google.com/*",
             scripts[0].url_patterns()[0].GetAsString());
   EXPECT_EQ("https://*.google.com/*",
             scripts[0].url_patterns()[1].GetAsString());
   EXPECT_EQ(2u, scripts[0].js_scripts().size());
-  EXPECT_EQ(extension->path().AppendASCII("script1.js").value(),
-            scripts[0].js_scripts()[0].path().value());
-  EXPECT_EQ(extension->path().AppendASCII("script2.js").value(),
-            scripts[0].js_scripts()[1].path().value());
+  EXPECT_EQ(
+      NormalizeSeperators(extension->path().AppendASCII("script1.js").value()),
+      NormalizeSeperators(scripts[0].js_scripts()[0].path().value()));
+  EXPECT_EQ(
+      NormalizeSeperators(extension->path().AppendASCII("script2.js").value()),
+      NormalizeSeperators(scripts[0].js_scripts()[1].path().value()));
   EXPECT_TRUE(extension->plugins().empty());
   EXPECT_EQ(1u, scripts[1].url_patterns().size());
   EXPECT_EQ("http://*.news.com/*", scripts[1].url_patterns()[0].GetAsString());
-  EXPECT_EQ(extension->path().AppendASCII("js_files").AppendASCII("script3.js")
-      .value(), scripts[1].js_scripts()[0].path().value());
+  EXPECT_EQ(
+      NormalizeSeperators(extension->path()
+                          .AppendASCII("js_files")
+                          .AppendASCII("script3.js")
+                          .value()),
+      NormalizeSeperators(scripts[1].js_scripts()[0].path().value()));
   const std::vector<URLPattern> permissions = extension->permissions();
   ASSERT_EQ(2u, permissions.size());
   EXPECT_EQ("http://*.google.com/*", permissions[0].GetAsString());
   EXPECT_EQ("https://*.google.com/*", permissions[1].GetAsString());
   ASSERT_EQ(2u, toolstrips.size());
   EXPECT_EQ("toolstrip1.html", toolstrips[0]);
   EXPECT_EQ("toolstrip2.html", toolstrips[1]);
 
   EXPECT_EQ(std::string(good1), loaded_[1]->id());
   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
   EXPECT_EQ(std::string(""), loaded_[1]->description());
-  EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
-            loaded_[1]->background_url());
+  // TODO(erikkay): re-enable:
+  // http://code.google.com/p/chromium/issues/detail?id=15363.
+  // EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
+  //          loaded_[1]->background_url());
   EXPECT_EQ(0u, loaded_[1]->content_scripts().size());
   EXPECT_EQ(2u, loaded_[1]->plugins().size());
   EXPECT_EQ(loaded_[1]->path().AppendASCII("content_plugin.dll").value(),
             loaded_[1]->plugins()[0].path.value());
   EXPECT_TRUE(loaded_[1]->plugins()[0].is_public);
   EXPECT_EQ(loaded_[1]->path().AppendASCII("extension_plugin.dll").value(),
             loaded_[1]->plugins()[1].path.value());
   EXPECT_FALSE(loaded_[1]->plugins()[1].is_public);
   EXPECT_EQ(Extension::INTERNAL, loaded_[1]->location());
 
   EXPECT_EQ(std::string(good2), loaded_[2]->id());
   EXPECT_EQ(std::string("My extension 3"), loaded_[2]->name());
   EXPECT_EQ(std::string(""), loaded_[2]->description());
   EXPECT_EQ(0u, loaded_[2]->content_scripts().size());
   EXPECT_EQ(Extension::INTERNAL, loaded_[2]->location());
 };
 
 // Test loading bad extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, DISABLED_LoadAllExtensionsFromDirectoryFail) {
-  FilePath source_path;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_path));
-  source_path = source_path.AppendASCII("extensions");
-  source_path = source_path.AppendASCII("bad");
+TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectoryFail) {
+  // Initialize the test dir with a good Preferences/extensions.
+  FilePath source_install_dir;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
+  source_install_dir = source_install_dir
+      .AppendASCII("extensions")
+      .AppendASCII("bad")
+      .AppendASCII("Extensions");
+  FilePath pref_path = source_install_dir
+      .DirName()
+      .AppendASCII("Preferences");
 
-  FilePath dest_path = profile_->GetPath().AppendASCII("Extensions");
-  file_util::CopyDirectory(source_path, dest_path, true);  // Recursive.
+  InitializeInstalledExtensionsService(pref_path, source_install_dir);
 
   service_->Init();
   loop_.RunAllPending();
 
-  EXPECT_EQ(3u, GetErrors().size());
-  EXPECT_EQ(0u, loaded_.size());
-
-  // Make sure the dictionary is empty.
-  ValidatePrefKeyCount(0);
+  ASSERT_EQ(4u, GetErrors().size());
+  ASSERT_EQ(0u, loaded_.size());
 
   EXPECT_TRUE(MatchPattern(GetErrors()[0],
       std::string("Could not load extension from '*'. * ") +
       JSONReader::kBadRootElementType)) << GetErrors()[0];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[1],
       std::string("Could not load extension from '*'. ") +
       Extension::kInvalidManifestError)) << GetErrors()[1];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[2],
       std::string("Could not load extension from '*'. ") +
       Extension::kMissingFileError)) << GetErrors()[2];
+
+  EXPECT_TRUE(MatchPattern(GetErrors()[3],
+      std::string("Could not load extension from '*'. ") +
+      Extension::kInvalidManifestError)) << GetErrors()[3];
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionsServiceTest, CleanupOnStartup) {
+  InitializeEmptyExtensionsService();
+
   FilePath source_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_path));
-  source_path = source_path.AppendASCII("extensions");
-  source_path = source_path.AppendASCII("good");
+  source_path = source_path.AppendASCII("extensions")
+                           .AppendASCII("good")
+                           .AppendASCII("Extensions");
 
-  FilePath dest_path = profile_->GetPath().AppendASCII("Extensions");
-  file_util::CopyDirectory(source_path, dest_path, true);  // Recursive.
+  file_util::Delete(extensions_install_dir_, true);
+
+  // Recursive.
+  file_util::CopyDirectory(source_path, extensions_install_dir_, true);
 
   // Simulate that one of them got partially deleted by deling the
   // Current Version file.
-  FilePath vers = dest_path.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+  FilePath vers = extensions_install_dir_
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII(ExtensionsService::kCurrentVersionFileName);
   ASSERT_TRUE(file_util::Delete(vers, false));  // not recursive
 
   service_->Init();
   loop_.RunAllPending();
 
-  file_util::FileEnumerator dirs(dest_path, false,
+  file_util::FileEnumerator dirs(extensions_install_dir_, false,
                                  file_util::FileEnumerator::DIRECTORIES);
   size_t count = 0;
   while (!dirs.Next().empty())
     count++;
 
   // We should have only gotten two extensions now.
   EXPECT_EQ(2u, count);
 
   // And extension1 dir should now be toast.
   vers = vers.DirName();
   ASSERT_FALSE(file_util::PathExists(vers));
 }
 
 // Test installing extensions.
 TEST_F(ExtensionsServiceTest, InstallExtension) {
+  InitializeEmptyExtensionsService();
+
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // Extensions not enabled.
   SetExtensionsEnabled(false);
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, false);
   SetExtensionsEnabled(true);
 
@@ skipping 31 matching lines @@
   ValidatePrefKeyCount(pref_count);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 #if defined(OS_WIN)  // TODO(port)
 // Test Packaging and installing an extension.
 // TODO(rafaelw): add more tests for failure cases.
 TEST_F(ExtensionsServiceTest, PackExtension) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
-  FilePath input_directory = extensions_path.AppendASCII("good")
-      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
+  FilePath input_directory = extensions_path
+      .AppendASCII("good")
+      .AppendASCII("Extensions")
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+      .AppendASCII("1.0.0.0");
 
   FilePath output_directory;
   file_util::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_"),
       &output_directory);
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, FilePath(),
       privkey_path));
 
   ASSERT_TRUE(file_util::PathExists(privkey_path));
   InstallExtension(crx_path, true);
 
   file_util::Delete(crx_path, false);
   file_util::Delete(privkey_path, false);
 }
 
 // Test Packaging and installing an extension using an openssl generated key.
 // The openssl is generated with the following:
 // > openssl genrsa -out privkey.pem 1024
 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
 // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
 // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
 TEST_F(ExtensionsServiceTest, PackExtensionOpenSSLKey) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
-  FilePath input_directory = extensions_path.AppendASCII("good")
-      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
+  FilePath input_directory = extensions_path
+      .AppendASCII("good")
+      .AppendASCII("Extensions")
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+      .AppendASCII("1.0.0.0");
   FilePath privkey_path(extensions_path.AppendASCII(
       "openssl_privkey_asn1.pem"));
   ASSERT_TRUE(file_util::PathExists(privkey_path));
 
   FilePath output_directory;
   file_util::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_"),
       &output_directory);
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
       FilePath()));
 
   InstallExtension(crx_path, true);
 
   file_util::Delete(crx_path, false);
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, InstallTheme) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A theme.
   FilePath path = extensions_path.AppendASCII("theme.crx");
   InstallExtension(path, true);
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
   ValidatePref(theme_crx, L"state", Extension::ENABLED);
@@ skipping 16 matching lines @@
   ValidatePrefKeyCount(pref_count);
 
   // A theme with image resources missing (misspelt path).
   path = extensions_path.AppendASCII("theme_missing_image.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 }
 
 // Test that when an extension version is reinstalled, nothing happens.
 TEST_F(ExtensionsServiceTest, Reinstall) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
@@ skipping 14 matching lines @@
   ASSERT_FALSE(installed_);
   ASSERT_EQ(0u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::INTERNAL);
 }
 
 // Test upgrading a signed extension.
 TEST_F(ExtensionsServiceTest, UpgradeSignedGood) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 
   // Upgrade to version 2.0
   path = extensions_path.AppendASCII("good2.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 }
 
 // Test upgrading a signed extension with a bad signature.
 TEST_F(ExtensionsServiceTest, UpgradeSignedBad) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
   installed_ = NULL;
 
   // Try upgrading with a bad signature. This should fail during the unpack,
   // because the key will not match the signature.
   path = extensions_path.AppendASCII("good2_bad_signature.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_FALSE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(1u, GetErrors().size());
 }
 
 // Test a normal update via the UpdateExtension API
 TEST_F(ExtensionsServiceTest, UpdateExtension) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   path = extensions_path.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, true, true, true);
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
 }
 
 // Test doing an update without passing a completion callback
 TEST_F(ExtensionsServiceTest, UpdateWithoutCallback) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   path = extensions_path.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, true, false, true);
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
 }
 
 // Test updating a not-already-installed extension - this should fail
 TEST_F(ExtensionsServiceTest, UpdateNotInstalledExtension) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->UpdateExtension(good_crx, path, false, NULL);
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, service_->extensions()->size());
   ASSERT_FALSE(installed_);
   ASSERT_EQ(0u, loaded_.size());
 }
 
 // Makes sure you can't downgrade an extension via UpdateExtension
 TEST_F(ExtensionsServiceTest, UpdateWillNotDowngrade) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good2.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.1", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Change path from good2.crx -> good.crx
   path = extensions_path.AppendASCII("good.crx");
   UpdateExtension(good_crx, path, false, true, true);
   ASSERT_EQ("1.0.0.1", service_->extensions()->at(0)->VersionString());
 }
 
 // Make sure calling update with an identical version does nothing
 TEST_F(ExtensionsServiceTest, UpdateToSameVersionIsNoop) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   Extension* good = service_->extensions()->at(0);
   ASSERT_EQ(good_crx, good->id());
   UpdateExtension(good_crx, path, false, true, false);
 }
 
 // Tests uninstalling normal extensions
 TEST_F(ExtensionsServiceTest, UninstallExtension) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
   // The directory should be there now.
-  FilePath install_path = profile_->GetPath().AppendASCII("Extensions");
   const char* extension_id = good_crx;
-  FilePath extension_path = install_path.AppendASCII(extension_id);
+  FilePath extension_path = extensions_install_dir_.AppendASCII(extension_id);
   EXPECT_TRUE(file_util::PathExists(extension_path));
 
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::INTERNAL);
 
   // Uninstall it.
   service_->UninstallExtension(extension_id, false);
   total_successes_ = 0;
 
@@ skipping 19 matching lines @@
   EXPECT_TRUE(file_util::Delete(current_version_file, true));
   service_->UninstallExtension(extension_id, false);
   loop_.RunAllPending();
   EXPECT_FALSE(file_util::PathExists(extension_path));
 
   ValidatePrefKeyCount(0);
 }
 
 // Tests loading single extensions (like --load-extension)
 TEST_F(ExtensionsServiceTest, LoadExtension) {
+  InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
-  FilePath ext1 = extensions_path.AppendASCII("good")
+  FilePath ext1 = extensions_path
+      .AppendASCII("good")
+      .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
   service_->LoadExtension(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());
 
   // --load-extension doesn't add entries to prefs
   ValidatePrefKeyCount(0);
 
-  FilePath no_manifest = extensions_path.AppendASCII("bad")
-      .AppendASCII("cccccccccccccccccccccccccccccccc").AppendASCII("1");
+  FilePath no_manifest = extensions_path
+      .AppendASCII("bad")
+      //.AppendASCII("Extensions")
+      .AppendASCII("cccccccccccccccccccccccccccccccc")
+      .AppendASCII("1");
   service_->LoadExtension(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);
   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(ExtensionsServiceTest, GenerateID) {
+  InitializeEmptyExtensionsService();
   Extension::ResetGeneratedIdCounter();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath no_id_ext = extensions_path.AppendASCII("no_id");
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
@@ skipping 17 matching lines @@
 
   // --load-extension doesn't add entries to prefs
   ValidatePrefKeyCount(0);
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, ExternalInstallRegistry) {
   // This should all work, even when normal extension installation is disabled.
+  InitializeEmptyExtensionsService();
   SetExtensionsEnabled(false);
-
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* reg_provider =
       new MockExtensionProvider(Extension::EXTERNAL_REGISTRY);
   SetMockExternalProvider(Extension::EXTERNAL_REGISTRY, reg_provider);
 
@@ skipping 43 matching lines @@
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_REGISTRY);
 
   // Uninstall the extension and reload. Nothing should happen because the
   // preference should prevent us from reinstalling.
   std::string id = loaded_[0]->id();
   service_->UninstallExtension(id, false);
   loop_.RunAllPending();
 
   // The extension should also be gone from the install directory.
-  FilePath install_path = profile_->GetPath().AppendASCII("Extensions")
-                                             .AppendASCII(id);
+  FilePath install_path = extensions_install_dir_.AppendASCII(id);
   ASSERT_FALSE(file_util::PathExists(install_path));
 
   loaded_.clear();
   service_->CheckForUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::KILLBIT);  // It is an ex-parrot.
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_REGISTRY);
 
   // Now clear the preference, reinstall, then remove the reg key. The extension
   // should be uninstalled.
   SetPref(good_crx, L"state", Extension::ENABLED);
-  profile_->GetPrefs()->ScheduleSavePersistentPrefs();
+  prefs_->ScheduleSavePersistentPrefs();
 
   loaded_.clear();
   service_->CheckForUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(1u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_REGISTRY);
 
   // Now test an externally triggered uninstall (deleting the registry key).
   reg_provider->RemoveExtension(good_crx);
 
   loaded_.clear();
   service_->LoadAllExtensions();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(0);
 
   // The extension should also be gone from the install directory.
   ASSERT_FALSE(file_util::PathExists(install_path));
 }
 
 #endif
 
 TEST_F(ExtensionsServiceTest, ExternalInstallPref) {
+  InitializeEmptyExtensionsService();
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* pref_provider =
       new MockExtensionProvider(Extension::EXTERNAL_PREF);
   SetMockExternalProvider(Extension::EXTERNAL_PREF, pref_provider);
 
@@ skipping 43 matching lines @@
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // Uninstall the extension and reload. Nothing should happen because the
   // preference should prevent us from reinstalling.
   std::string id = loaded_[0]->id();
   service_->UninstallExtension(id, false);
   loop_.RunAllPending();
 
   // The extension should also be gone from the install directory.
-  FilePath install_path =
-      profile_->GetPath().AppendASCII("Extensions").AppendASCII(id);
+  FilePath install_path = extensions_install_dir_.AppendASCII(id);
   ASSERT_FALSE(file_util::PathExists(install_path));
 
   loaded_.clear();
   service_->CheckForUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::KILLBIT);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // Now clear the preference and reinstall.
   SetPref(good_crx, L"state", Extension::ENABLED);
-  profile_->GetPrefs()->ScheduleSavePersistentPrefs();
+  prefs_->ScheduleSavePersistentPrefs();
 
   loaded_.clear();
   service_->CheckForUpdates();
   loop_.RunAllPending();
   ASSERT_EQ(1u, loaded_.size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // Now test an externally triggered uninstall (deleting id from json file).
@@ skipping 15 matching lines @@
   service_->CheckForUpdates();
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, loaded_.size());
   ASSERT_EQ(1u, GetErrors().size());
   ASSERT_TRUE(GetErrors()[0].find("Extensions are not enabled") !=
               std::string::npos);
 }
 
 TEST_F(ExtensionsServiceTest, ExternalPrefProvider) {
+  InitializeEmptyExtensionsService();
   std::string json_data =
       "{"
         "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
           "\"external_crx\": \"RandomExtension.crx\","
           "\"external_version\": \"1.0\""
         "},"
         "\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
           "\"external_crx\": \"RandomExtension2.crx\","
           "\"external_version\": \"2.0\""
         "}"
@@ skipping 34 matching lines @@
 }
 
 // Test that we get enabled/disabled correctly for all the pref/command-line
 // combinations. We don't want to derive from the ExtensionsServiceTest class
 // for this test, so we use ExtensionsServiceTestSimple.
 TEST(ExtensionsServiceTestSimple, Enabledness) {
   TestingProfile profile;
   MessageLoop loop;
   scoped_ptr<CommandLine> command_line;
   scoped_refptr<ExtensionsService> service;
+  FilePath install_dir = profile.GetPath()
+      .AppendASCII(ExtensionsService::kInstallDirectoryName);
 
   // By default, we are disabled.
   command_line.reset(new CommandLine(L""));
-  service = new ExtensionsService(&profile, command_line.get(), &loop, &loop);
+  service = new ExtensionsService(&profile, command_line.get(),
+      profile.GetPrefs(), install_dir, &loop, &loop);
   EXPECT_FALSE(service->extensions_enabled());
 
   // If either the command line or pref is set, we are enabled.
   command_line->AppendSwitch(switches::kEnableExtensions);
-  service = new ExtensionsService(&profile, command_line.get(), &loop, &loop);
+  service = new ExtensionsService(&profile, command_line.get(),
+      profile.GetPrefs(), install_dir, &loop, &loop);
   EXPECT_TRUE(service->extensions_enabled());
 
   profile.GetPrefs()->SetBoolean(prefs::kEnableExtensions, true);
-  service = new ExtensionsService(&profile, command_line.get(), &loop, &loop);
+  service = new ExtensionsService(&profile, command_line.get(),
+      profile.GetPrefs(), install_dir, &loop, &loop);
   EXPECT_TRUE(service->extensions_enabled());
 
   command_line.reset(new CommandLine(L""));
-  service = new ExtensionsService(&profile, command_line.get(), &loop, &loop);
+  service = new ExtensionsService(&profile, command_line.get(),
+      profile.GetPrefs(), install_dir, &loop, &loop);
   EXPECT_TRUE(service->extensions_enabled());
 }