Make Blacklist::IsBlacklist asynchronous (it will need to be for safe

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 608 matching lines @@
     installer->set_creation_flags(creation_flags);
     if (!(creation_flags & Extension::WAS_INSTALLED_BY_DEFAULT)) {
       installer->set_allow_silent_install(true);
     }
     installer->InstallCrx(crx_path);
   }
 
   enum InstallState {
     INSTALL_FAILED,
     INSTALL_UPDATED,
-    INSTALL_NEW
+    INSTALL_NEW,
+    INSTALL_WITHOUT_LOAD,
   };
 
   const Extension* PackAndInstallCRX(const FilePath& dir_path,
                                      const FilePath& pem_path,
                                      InstallState install_state,
                                      int creation_flags) {
     FilePath crx_path;
     base::ScopedTempDir temp_dir;
     EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
     crx_path = temp_dir.path().AppendASCII("temp.crx");
@@ skipping 54 matching lines @@
   const Extension* WaitForCrxInstall(const FilePath& path,
                                      InstallState install_state) {
     loop_.RunUntilIdle();
     std::vector<string16> errors = GetErrors();
     const Extension* extension = NULL;
     if (install_state != INSTALL_FAILED) {
       if (install_state == INSTALL_NEW)
         ++expected_extensions_count_;
 
       EXPECT_TRUE(installed_) << path.value();
+      EXPECT_EQ(0u, errors.size()) << path.value();
 
-      EXPECT_EQ(1u, loaded_.size()) << path.value();
-      EXPECT_EQ(0u, errors.size()) << path.value();
-      EXPECT_EQ(expected_extensions_count_, service_->extensions()->size()) <<
-          path.value();
-      extension = loaded_[0];
-      EXPECT_TRUE(service_->GetExtensionById(extension->id(), false)) <<
-          path.value();
+      if (install_state == INSTALL_WITHOUT_LOAD) {
+        EXPECT_EQ(0u, loaded_.size()) << path.value();
+      } else {
+        EXPECT_EQ(1u, loaded_.size()) << path.value();
+        EXPECT_EQ(expected_extensions_count_, service_->extensions()->size()) <<
+            path.value();
+        extension = loaded_[0];
+        EXPECT_TRUE(service_->GetExtensionById(extension->id(), false)) <<
+            path.value();
+      }
+
       for (std::vector<string16>::iterator err = errors.begin();
         err != errors.end(); ++err) {
         LOG(ERROR) << *err;
       }
     } else {
       EXPECT_FALSE(installed_) << path.value();
       EXPECT_EQ(0u, loaded_.size()) << path.value();
       EXPECT_EQ(1u, errors.size()) << path.value();
     }
 
@@ skipping 2269 matching lines @@
                                                                     "v1");
 
   // Make sure pref is updated
   loop_.RunUntilIdle();
 
   // Now, the good_crx is blacklisted.
   ValidateBooleanPref(good_crx, "blacklist", true);
 
   // We can not install good_crx.
   FilePath path = data_dir_.AppendASCII("good.crx");
-  InstallCRX(path, INSTALL_FAILED);
+  InstallCRX(path, INSTALL_WITHOUT_LOAD);
   EXPECT_EQ(0u, service_->extensions()->size());
   ValidateBooleanPref(good_crx, "blacklist", true);
 }
 
 // Unload blacklisted extension on policy change.
 TEST_F(ExtensionServiceTest, UnloadBlacklistedExtensionPolicy) {
   InitializeEmptyExtensionService();
   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(base::Value::CreateStringValue(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
+  loop_.RunUntilIdle();
 
-  // Now, the good_crx is blacklisted but whitelist negates it.
-  ValidateBooleanPref(good_crx, "blacklist", true);
-  EXPECT_EQ(1u, service_->extensions()->size());
-
-  whitelist.Clear();
-  prefs->Set(prefs::kExtensionInstallAllowList, whitelist);
-
-  // Now, the good_crx is blacklisted for good.
+  // The good_crx is blacklisted and the whitelist doesn't negate it.
   ValidateBooleanPref(good_crx, "blacklist", true);
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
-// Allow Google-blacklisted extension if policy explicitly allows it (blacklist
-// then set policy).
-TEST_F(ExtensionServiceTest, WhitelistGoogleBlacklistedExtension) {
-  InitializeEmptyExtensionService();
-
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
-
-  FilePath path = data_dir_.AppendASCII("good.crx");
-  InstallCRX(path, INSTALL_FAILED);
-
-  base::ListValue whitelist;
-  whitelist.Append(base::Value::CreateStringValue(good_crx));
-  service_->extension_prefs()->pref_service()->Set(
-      prefs::kExtensionInstallAllowList, whitelist);
-
-  InstallCRX(path, INSTALL_NEW);
-}
-
-// Allow Google-blacklisted extension if policy requires it (blacklist then set
-// policy).
-TEST_F(ExtensionServiceTest, ForcelistGoogleBlacklistedExtension) {
-  InitializeEmptyExtensionService();
-
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
-
-  FilePath path = data_dir_.AppendASCII("good.crx");
-  InstallCRX(path, INSTALL_FAILED);
-
-  base::ListValue forcelist;
-  forcelist.Append(base::Value::CreateStringValue(good_crx));
-  service_->extension_prefs()->pref_service()->Set(
-      prefs::kExtensionInstallAllowList, forcelist);
-
-  InstallCRX(path, INSTALL_NEW);
-}
-
-// Allow Google-blacklisted extension if policy explicitly allows it (set policy
-// then blacklist).
-TEST_F(ExtensionServiceTest, GoogleBlacklistWhitelistedExtension) {
-  InitializeEmptyExtensionService();
-
-  base::ListValue whitelist;
-  whitelist.Append(base::Value::CreateStringValue(good_crx));
-  service_->extension_prefs()->pref_service()->Set(
-      prefs::kExtensionInstallAllowList, whitelist);
-
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
-
-  InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
-}
-
-// Allow Google-blacklisted extension if policy requires it (set policy then
-// blacklist).
-TEST_F(ExtensionServiceTest, GoogleBlacklistForcelistedExtension) {
-  InitializeEmptyExtensionService();
-
-  base::ListValue forcelist;
-  forcelist.Append(base::Value::CreateStringValue(good_crx));
-  service_->extension_prefs()->pref_service()->Set(
-      prefs::kExtensionInstallAllowList, forcelist);
-
-  std::vector<std::string> blacklist;
-  blacklist.push_back(good_crx);
-  ExtensionSystem::Get(profile_.get())->blacklist()->SetFromUpdater(blacklist,
-                                                                    "v1");
-
-  InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
-}
-
 // Test loading extensions from the profile directory, except
 // blacklisted ones.
 TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
@@ skipping 13 matching lines @@
   // Load extensions.
   service_->Init();
 
   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());
 
-  EXPECT_FALSE(service_->GetExtensionById(good1, true));
+  EXPECT_TRUE(service_->GetInstalledExtension(good1));
+  int include_mask = ExtensionService::INCLUDE_EVERYTHING &
+                    ~ExtensionService::INCLUDE_BLACKLISTED;
+  EXPECT_FALSE(service_->GetExtensionById(good1, include_mask));
 }
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionService();
 
   // Blacklist everything.
   {
     ListPrefUpdate update(profile_->GetPrefs(),
                           prefs::kExtensionInstallDenyList);
@@ skipping 2688 matching lines @@
   EXPECT_FALSE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
 
   ExtensionPrefs* prefs = service_->extension_prefs();
   EXPECT_NE(0, prefs->GetDisableReasons(good_crx) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
   EXPECT_EQ(0, prefs->GetDisableReasons(page_action) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
 }