Delete the omahaproxy-backed extension blacklist and clear its entries from the

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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 13 matching lines @@
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/app_sync_data.h"
+#include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_error_ui.h"
 #include "chrome/browser/extensions/extension_notification_observer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_sorting.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/external_install_ui.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/external_pref_loader.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/external_provider_interface.h"
+#include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
 #include "chrome/browser/extensions/install_observer.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/extensions/pack_extension_job.h"
 #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/test_management_policy.h"
@@ skipping 56 matching lines @@
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/database/database_identifier.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/extensions/install_limiter.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
+// The blacklist tests rely on safe browsing.
+#if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
+#define ENABLE_BLACKLIST_TESTS
+#endif
+
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DOMStorageContext;
 using content::IndexedDBContext;
 using content::PluginService;
 using extensions::APIPermission;
 using extensions::APIPermissionSet;
+using extensions::Blacklist;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionCreator;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionResource;
 using extensions::ExtensionSystem;
+using extensions::FakeSafeBrowsingDatabaseManager;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 using extensions::PermissionSet;
 using extensions::TestExtensionSystem;
 using extensions::URLPatternSet;
 
 namespace keys = extensions::manifest_keys;
 
 namespace {
 
@@ skipping 374 matching lines @@
   base::DeleteFile(extensions_install_dir_, 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()
+      .AppendASCII("Preferences");
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
+}
+
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
   InitializeExtensionServiceHelper(false, true);
 }
 
 void ExtensionServiceTestBase::InitializeExtensionProcessManager() {
   static_cast<extensions::TestExtensionSystem*>(
       ExtensionSystem::Get(profile_.get()))->
       CreateExtensionProcessManager();
 }
 
@@ skipping 103 matching lines @@
   }
 
   void MockSyncStartFlare(bool* was_called,
                           syncer::ModelType* model_type_passed_in,
                           syncer::ModelType model_type) {
     *was_called = true;
     *model_type_passed_in = model_type;
   }
 
  protected:
+  // Paths to some of the fake extensions.
+  base::FilePath good0_path() {
+    return data_dir_.AppendASCII("good").AppendASCII("Extensions")
+                    .AppendASCII(good0).AppendASCII("1.0.0.0");
+  }
+
+  base::FilePath good1_path() {
+    return data_dir_.AppendASCII("good").AppendASCII("Extensions")
+                    .AppendASCII(good1).AppendASCII("2");
+  }
+
+  base::FilePath good2_path() {
+    return data_dir_.AppendASCII("good").AppendASCII("Extensions")
+                    .AppendASCII(good2).AppendASCII("1.0");
+  }
+
   void TestExternalProvider(MockExtensionProvider* provider,
                             Manifest::Location location);
 
   void PackCRX(const base::FilePath& dir_path,
                const base::FilePath& pem_path,
                const base::FilePath& crx_path) {
     // Use the existing pem key, if provided.
     base::FilePath pem_output_path;
     if (pem_path.value().empty()) {
       pem_output_path = crx_path.DirName().AppendASCII("temp.pem");
@@ skipping 319 matching lines @@
     base::RunLoop().RunUntilIdle();
 
     // The directory should be gone.
     EXPECT_FALSE(base::PathExists(extension_path));
   }
 
   void ValidatePrefKeyCount(size_t count) {
     EXPECT_EQ(count, GetPrefKeyCount());
   }
 
-  void ValidateBooleanPref(const std::string& extension_id,
-                           const std::string& pref_path,
-                           bool expected_val) {
-    std::string msg = " while checking: ";
+  testing::AssertionResult ValidateBooleanPref(
+      const std::string& extension_id,
+      const std::string& pref_path,
+      bool expected_val) {
+    std::string msg = "while checking: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     msg += " == ";
     msg += expected_val ? "true" : "false";
 
     PrefService* prefs = profile_->GetPrefs();
     const DictionaryValue* dict =
         prefs->GetDictionary("extensions.settings");
-    ASSERT_TRUE(dict != NULL) << msg;
+    if (!dict) {
+      return testing::AssertionFailure()
+          << "extension.settings does not exist " << msg;
+    }
+
     const DictionaryValue* pref = NULL;
-    ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
-    EXPECT_TRUE(pref != NULL) << msg;
+    if (!dict->GetDictionary(extension_id, &pref)) {
+      return testing::AssertionFailure()
+          << "extension pref does not exist " << msg;
+    }
+
     bool val;
-    ASSERT_TRUE(pref->GetBoolean(pref_path, &val)) << msg;
-    EXPECT_EQ(expected_val, val) << msg;
+    if (!pref->GetBoolean(pref_path, &val)) {
+      return testing::AssertionFailure()
+          << pref_path << " pref not found " << msg;
+    }
+
+    return expected_val == val
+        ? testing::AssertionSuccess()
+        : testing::AssertionFailure() << "Value is incorrect " << msg;
   }
 
   bool IsPrefExist(const std::string& extension_id,
                    const std::string& pref_path) {
     const DictionaryValue* dict =
         profile_->GetPrefs()->GetDictionary("extensions.settings");
     if (dict == NULL) return false;
     const DictionaryValue* pref = NULL;
     if (!dict->GetDictionary(extension_id, &pref)) {
       return false;
@@ skipping 179 matching lines @@
                                             ExtensionCreator::ErrorType type) {
   if (type == ExtensionCreator::kCRXExists)
      FAIL() << "Packing should not fail.";
   else
      FAIL() << "Existing CRX should have been overwritten.";
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
   InitPluginService();
-
-  // Initialize the test dir with a good Preferences/extensions.
-  base::FilePath source_install_dir = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions");
-  base::FilePath pref_path = source_install_dir
-      .DirName()
-      .AppendASCII("Preferences");
-  InitializeInstalledExtensionService(pref_path, source_install_dir);
-
+  InitializeGoodInstalledExtensionService();
   service_->Init();
 
   uint32 expected_num_extensions = 3u;
   ASSERT_EQ(expected_num_extensions, loaded_.size());
 
   EXPECT_EQ(std::string(good0), loaded_[0]->id());
   EXPECT_EQ(std::string("My extension 1"),
             loaded_[0]->name());
   EXPECT_EQ(std::string("The first extension that I made."),
             loaded_[0]->description());
@@ skipping 122 matching lines @@
   EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[3]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
       UTF16ToUTF8(GetErrors()[3]);
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionServiceTest, CleanupOnStartup) {
   InitPluginService();
-
-  base::FilePath source_install_dir = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions");
-  base::FilePath pref_path = source_install_dir
-      .DirName()
-      .AppendASCII("Preferences");
-
-  InitializeInstalledExtensionService(pref_path, source_install_dir);
+  InitializeGoodInstalledExtensionService();
 
   // Simulate that one of them got partially deleted by clearing its pref.
   {
     DictionaryPrefUpdate update(profile_->GetPrefs(), "extensions.settings");
     DictionaryValue* dict = update.Get();
     ASSERT_TRUE(dict != NULL);
     dict->Remove("behllobkkfkfnphdnhnkndlbkcpglgmj", NULL);
   }
 
   service_->Init();
@@ skipping 306 matching lines @@
           Extension::FROM_BOOKMARK,
           false /* mark_acknowledged */)) {
     content::WindowedNotificationObserver(
         chrome::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources()).Wait();
   }
 
   const Extension* extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
-  ValidateBooleanPref(good_crx, kPrefFromBookmark, true);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
 
   // Upgrade to version 2.0, the flag should be preserved.
   path = data_dir_.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, ENABLED);
-  ValidateBooleanPref(good_crx, kPrefFromBookmark, true);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
   extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
 }
 
 // Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
@@ skipping 279 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 // Tests that the granted permissions full_access bit gets set correctly when
 // an extension contains an NPAPI plugin. Don't run this test on Chrome OS
 // since they don't support plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitPluginService();
 
   InitializeEmptyExtensionService();
 
-  base::FilePath path = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions")
-      .AppendASCII(good1)
-      .AppendASCII("2");
-
-  ASSERT_TRUE(base::PathExists(path));
-  const Extension* extension = PackAndInstallCRX(path, INSTALL_NEW);
+  ASSERT_TRUE(base::PathExists(good1_path()));
+  const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, service_->extensions()->size());
   ExtensionPrefs* prefs = service_->extension_prefs();
 
   scoped_refptr<PermissionSet> permissions(
       prefs->GetGrantedPermissions(extension->id()));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
@@ skipping 701 matching lines @@
 TEST_F(ExtensionServiceTest, FromWebStore) {
   InitializeEmptyExtensionService();
 
   // A simple extension that should install without error.
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   // Not from web store.
   const Extension* extension = InstallCRX(path, INSTALL_NEW);
   std::string id = extension->id();
 
   ValidatePrefKeyCount(1);
-  ValidateBooleanPref(good_crx, "from_webstore", false);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", false));
   ASSERT_FALSE(extension->from_webstore());
 
   // Test install from web store.
   InstallCRXFromWebStore(path, INSTALL_UPDATED);  // From web store.
 
   ValidatePrefKeyCount(1);
-  ValidateBooleanPref(good_crx, "from_webstore", true);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
 
   // Reload so extension gets reinitialized with new value.
   service_->ReloadExtensions();
   extension = service_->GetExtensionById(id, false);
   ASSERT_TRUE(extension->from_webstore());
 
   // Upgrade to version 2.0
   path = data_dir_.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, ENABLED);
   ValidatePrefKeyCount(1);
-  ValidateBooleanPref(good_crx, "from_webstore", true);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
 }
 
 // Test upgrading a signed extension.
 TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   const Extension* extension = InstallCRX(path, INSTALL_NEW);
   std::string id = extension->id();
 
@@ skipping 192 matching lines @@
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("1.0", loaded_[0]->VersionString());
 }
 
 #if !defined(OS_CHROMEOS)
 // LOAD extensions with plugins require approval.
 TEST_F(ExtensionServiceTest, LoadExtensionsWithPlugins) {
-  base::FilePath extension_with_plugin_path = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions")
-      .AppendASCII(good1)
-      .AppendASCII("2");
-  base::FilePath extension_no_plugin_path = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions")
-      .AppendASCII(good2)
-      .AppendASCII("1.0");
+  base::FilePath extension_with_plugin_path = good1_path();
+  base::FilePath extension_no_plugin_path = good2_path();
 
   InitPluginService();
   InitializeEmptyExtensionService();
   InitializeExtensionProcessManager();
   service_->set_show_extensions_prompts(true);
 
   // Start by canceling any install prompts.
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kAppsGalleryInstallAutoConfirmForTests,
       "cancel");
@@ skipping 274 matching lines @@
   // Use AddExtensionImpl() as AddFrom*() would balk.
   service_->pending_extension_manager()->AddExtensionImpl(
       good->id(), extensions::ManifestURL::GetUpdateURL(good),
       Version(), &IsExtension, kGoodIsFromSync,
       kGoodInstallSilently, Manifest::INTERNAL);
   UpdateExtension(good->id(), path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
 }
 
-// Test pref settings for blacklist and unblacklist extensions.
+#if defined(ENABLE_BLACKLIST_TESTS)
+// Tests blacklisting then unblacklisting extensions after the service has been
+// initialized.
 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
-  InitializeEmptyExtensionService();
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good0);
-  blacklist.push_back("invalid_id");  // an invalid id
-  blacklist.push_back(good1);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
+  scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
+      new FakeSafeBrowsingDatabaseManager(true));
+  Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
 
-  // Make sure pref is updated
+  // A profile with 3 extensions installed: good0, good1, and good2.
+  InitializeGoodInstalledExtensionService();
+  service_->Init();
+
+  const ExtensionSet* extensions = service_->extensions();
+  const ExtensionSet* blacklisted_extensions =
+      service_->blacklisted_extensions();
+
+  EXPECT_TRUE( extensions->Contains(good0) &&
+              !blacklisted_extensions->Contains(good0));
+  EXPECT_TRUE( extensions->Contains(good1) &&
+              !blacklisted_extensions->Contains(good1));
+  EXPECT_TRUE( extensions->Contains(good2) &&
+              !blacklisted_extensions->Contains(good2));
+
+  EXPECT_FALSE(IsPrefExist(good0, "blacklist"));
+  EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
+  EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
+  EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
+
+  // Blacklist good0 and good1 (and an invalid extension ID).
+  blacklist_db->SetUnsafe(good0, good1, "invalid_id").NotifyUpdate();
   base::RunLoop().RunUntilIdle();
 
-  // blacklist is set for good0,1,2
-  ValidateBooleanPref(good0, "blacklist", true);
-  ValidateBooleanPref(good1, "blacklist", true);
-  // invalid_id should not be inserted to pref.
+  EXPECT_TRUE(!extensions->Contains(good0) &&
+               blacklisted_extensions->Contains(good0));
+  EXPECT_TRUE(!extensions->Contains(good1) &&
+               blacklisted_extensions->Contains(good1));
+  EXPECT_TRUE( extensions->Contains(good2) &&
+              !blacklisted_extensions->Contains(good2));
+
+  EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
+  EXPECT_TRUE(ValidateBooleanPref(good1, "blacklist", true));
+  EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 
-  // remove good1, add good2
-  blacklist.pop_back();
-  blacklist.push_back(good2);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v2");
+  // Un-blacklist good1 and blacklist good2.
+  blacklist_db->SetUnsafe(good0, good2, "invalid_id").NotifyUpdate();
+  base::RunLoop().RunUntilIdle();
 
-  // only good0 and good1 should be set
-  ValidateBooleanPref(good0, "blacklist", true);
+  EXPECT_TRUE(!extensions->Contains(good0) &&
+               blacklisted_extensions->Contains(good0));
+  EXPECT_TRUE( extensions->Contains(good1) &&
+              !blacklisted_extensions->Contains(good1));
+  EXPECT_TRUE(!extensions->Contains(good2) &&
+               blacklisted_extensions->Contains(good2));
+
+  EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
-  ValidateBooleanPref(good2, "blacklist", true);
+  EXPECT_TRUE(ValidateBooleanPref(good2, "blacklist", true));
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 }
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
 
-// Unload installed extension from blacklist.
-TEST_F(ExtensionServiceTest, UnloadBlacklistedExtension) {
+#if defined(ENABLE_BLACKLIST_TESTS)
+// Tests trying to install a blacklisted extension.
+TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
+  scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
+      new FakeSafeBrowsingDatabaseManager(true));
+  Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
+
   InitializeEmptyExtensionService();
+  service_->Init();
 
-  base::FilePath path = data_dir_.AppendASCII("good.crx");
-
-  const Extension* good = InstallCRX(path, INSTALL_NEW);
-  EXPECT_EQ(good_crx, good->id());
-  UpdateExtension(good_crx, path, FAILED_SILENTLY);
-
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                     "v1");
-
-  // Make sure pref is updated
+  // After blacklisting good_crx, we cannot install it.
+  blacklist_db->SetUnsafe(good_crx).NotifyUpdate();
   base::RunLoop().RunUntilIdle();
 
-  // Now, the good_crx is blacklisted.
-  ValidateBooleanPref(good_crx, "blacklist", true);
-  EXPECT_EQ(0u, service_->extensions()->size());
-
-  // Remove good_crx from blacklist
-  blacklist.pop_back();
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                     "v2");
-
-  // Make sure pref is updated
-  base::RunLoop().RunUntilIdle();
-  // blacklist value should not be set for good_crx
-  EXPECT_FALSE(IsPrefExist(good_crx, "blacklist"));
-}
-
-// Unload installed extension from blacklist.
-TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
-  InitializeEmptyExtensionService();
-
-  // Fake the blacklisting of good_crx by pretending that we get an update
-  // which includes it.
-  extensions::Blacklist* blacklist =
-      ExtensionSystem::Get(profile_.get())->blacklist();
-  blacklist->SetFromUpdater(std::vector<std::string>(1, good_crx), "v1");
-
-  // Now good_crx is blacklisted.
-  ValidateBooleanPref(good_crx, "blacklist", true);
-
-  // We cannot install good_crx.
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   // HACK: specify WAS_INSTALLED_BY_DEFAULT so that test machinery doesn't
   // decide to install this silently. Somebody should fix these tests, all
   // 6,000 lines of them. Hah!
   InstallCRX(path, INSTALL_FAILED, Extension::WAS_INSTALLED_BY_DEFAULT);
   EXPECT_EQ(0u, service_->extensions()->size());
-  ValidateBooleanPref(good_crx, "blacklist", true);
 }
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
 
+#if defined(ENABLE_BLACKLIST_TESTS)
 // Unload blacklisted extension on policy change.
 TEST_F(ExtensionServiceTest, UnloadBlacklistedExtensionPolicy) {
+  scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
+      new FakeSafeBrowsingDatabaseManager(true));
+  Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
+
+  // A profile with no extensions installed.
   InitializeEmptyExtensionService();
+
   base::FilePath path = data_dir_.AppendASCII("good.crx");
 
   const Extension* good = InstallCRX(path, INSTALL_NEW);
   EXPECT_EQ(good_crx, good->id());
   UpdateExtension(good_crx, path, FAILED_SILENTLY);
   EXPECT_EQ(1u, service_->extensions()->size());
 
   base::ListValue whitelist;
   PrefService* prefs = service_->extension_prefs()->pref_service();
   whitelist.Append(new base::StringValue(good_crx));
   prefs->Set(prefs::kExtensionInstallAllowList, whitelist);
 
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
-
-  // Make sure pref is updated
+  blacklist_db->SetUnsafe(good_crx).NotifyUpdate();
   base::RunLoop().RunUntilIdle();
 
   // The good_crx is blacklisted and the whitelist doesn't negate it.
-  ValidateBooleanPref(good_crx, "blacklist", true);
+  ASSERT_TRUE(ValidateBooleanPref(good_crx, "blacklist", true));
   EXPECT_EQ(0u, service_->extensions()->size());
 }
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
 
-// Test loading extensions from the profile directory, except
-// blacklisted ones.
+#if defined(ENABLE_BLACKLIST_TESTS)
+// Tests that a blacklisted extension is eventually unloaded on startup, if it
+// wasn't already.
 TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
-  // Initialize the test dir with a good Preferences/extensions.
-  base::FilePath source_install_dir = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions");
-  base::FilePath pref_path = source_install_dir
-      .DirName()
-      .AppendASCII("Preferences");
-  InitializeInstalledExtensionService(pref_path, source_install_dir);
+  scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
+      new FakeSafeBrowsingDatabaseManager(true));
+  Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
 
-  // Blacklist good1.
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good1);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
+  // A profile with 3 extensions installed: good0, good1, and good2.
+  InitializeGoodInstalledExtensionService();
 
-  // Make sure pref is updated
-  base::RunLoop().RunUntilIdle();
-
-  ValidateBooleanPref(good1, "blacklist", true);
+  // Blacklist good1 before the service initializes.
+  blacklist_db->SetUnsafe(good1);
 
   // Load extensions.
   service_->Init();
+  ASSERT_EQ(3u, loaded_.size());  // hasn't had time to blacklist yet
 
-  std::vector<string16> errors = GetErrors();
-  for (std::vector<string16>::iterator err = errors.begin();
-    err != errors.end(); ++err) {
-    LOG(ERROR) << *err;
-  }
-  ASSERT_EQ(2u, loaded_.size());
+  base::RunLoop().RunUntilIdle();
+  ASSERT_EQ(1u, service_->blacklisted_extensions()->size());
+  ASSERT_EQ(2u, service_->extensions()->size());
 
-  EXPECT_TRUE(service_->GetInstalledExtension(good1));
-  int include_mask = ExtensionService::INCLUDE_EVERYTHING &
-                    ~ExtensionService::INCLUDE_BLACKLISTED;
-  EXPECT_FALSE(service_->GetExtensionById(good1, include_mask));
+  ASSERT_TRUE(service_->extensions()->Contains(good0));
+  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
+  ASSERT_TRUE(service_->extensions()->Contains(good2));
 }
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
+
+#if defined(ENABLE_BLACKLIST_TESTS)
+// Tests extensions blacklisted in prefs on startup; one still blacklisted by
+// safe browsing, the other not. The not-blacklisted one should recover.
+TEST_F(ExtensionServiceTest, BlacklistedInPrefsFromStartup) {
+  scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
+      new FakeSafeBrowsingDatabaseManager(true));
+  Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
+
+  InitializeGoodInstalledExtensionService();
+  service_->extension_prefs()->SetExtensionBlacklisted(good0, true);
+  service_->extension_prefs()->SetExtensionBlacklisted(good1, true);
+
+  blacklist_db->SetUnsafe(good1);
+
+  service_->Init();
+
+  ASSERT_EQ(2u, service_->blacklisted_extensions()->size());
+  ASSERT_EQ(1u, service_->extensions()->size());
+
+  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good0));
+  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
+  ASSERT_TRUE(service_->extensions()->Contains(good2));
+
+  // Give time for the blacklist to update.
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_EQ(1u, service_->blacklisted_extensions()->size());
+  ASSERT_EQ(2u, service_->extensions()->size());
+
+  ASSERT_TRUE(service_->extensions()->Contains(good0));
+  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
+  ASSERT_TRUE(service_->extensions()->Contains(good2));
+}
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionService();
 
   // Blacklist everything.
   {
     ListPrefUpdate update(profile_->GetPrefs(),
                           prefs::kExtensionInstallDenyList);
     ListValue* blacklist = update.Get();
@@ skipping 1677 matching lines @@
   bool flare_was_called = false;
   syncer::ModelType triggered_type(syncer::UNSPECIFIED);
   base::WeakPtrFactory<ExtensionServiceTest> factory(this);
   service_->SetSyncStartFlare(
       base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
                  factory.GetWeakPtr(),
                  &flare_was_called,  // Safe due to WeakPtrFactory scope.
                  &triggered_type));  // Safe due to WeakPtrFactory scope.
 
   // Install a component extension.
-  base::FilePath path = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions")
-      .AppendASCII(good0)
-      .AppendASCII("1.0.0.0");
   std::string manifest;
   ASSERT_TRUE(base::ReadFileToString(
-      path.Append(extensions::kManifestFilename), &manifest));
-  service_->component_loader()->Add(manifest, path);
+      good0_path().Append(extensions::kManifestFilename), &manifest));
+  service_->component_loader()->Add(manifest, good0_path());
   ASSERT_FALSE(service_->is_ready());
   service_->Init();
   ASSERT_TRUE(service_->is_ready());
 
   // Extensions added before service is_ready() don't trigger sync startup.
   EXPECT_FALSE(flare_was_called);
   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
 }
 
 TEST_F(ExtensionServiceTest, DeferredSyncStartupPreInstalledNormal) {
-  // Initialize the test dir with a good Preferences/extensions.
-  base::FilePath source_install_dir = data_dir_
-      .AppendASCII("good")
-      .AppendASCII("Extensions");
-  base::FilePath pref_path = source_install_dir
-      .DirName()
-      .AppendASCII("Preferences");
-  InitializeInstalledExtensionService(pref_path, source_install_dir);
+  InitializeGoodInstalledExtensionService();
 
   bool flare_was_called = false;
   syncer::ModelType triggered_type(syncer::UNSPECIFIED);
   base::WeakPtrFactory<ExtensionServiceTest> factory(this);
   service_->SetSyncStartFlare(
       base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
                  factory.GetWeakPtr(),
                  &flare_was_called,  // Safe due to WeakPtrFactory scope.
                  &triggered_type));  // Safe due to WeakPtrFactory scope.
 
@@ skipping 1238 matching lines @@
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_INSTALLED));
 
   EXPECT_TRUE(service_->GetInstalledExtension(id));
   EXPECT_FALSE(service_->extensions()->Contains(id));
   EXPECT_TRUE(service_->blacklisted_extensions()->Contains(id));
   EXPECT_TRUE(service_->extension_prefs()->IsExtensionBlacklisted(id));
   EXPECT_TRUE(
       service_->extension_prefs()->IsBlacklistedExtensionAcknowledged(id));
 }