Don't try to reload blacklisted extensions.

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 3000 matching lines @@
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
 }
 #endif  // !defined(OS_POSIX) || defined(OS_MACOSX)
 
 namespace {
 
 bool IsExtension(const Extension* extension) {
   return extension->GetType() == Manifest::TYPE_EXTENSION;
 }
 
+#if defined(ENABLE_BLACKLIST_TESTS)
+std::set<std::string> StringSet(const std::string& s) {
+  std::set<std::string> set;
+  set.insert(s);
+  return set;
+}
+std::set<std::string> StringSet(const std::string& s1, const std::string& s2) {
+  std::set<std::string> set = StringSet(s1);
+  set.insert(s2);
+  return set;
+}
+#endif  // defined(ENABLE_BLACKLIST_TESTS)
+
 }  // namespace
 
 // Test adding a pending extension.
 TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) {
   InitializeEmptyExtensionService();
 
   const std::string kFakeId(all_zero);
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const bool kFakeInstallSilently(true);
   const bool kFakeRemoteInstall(false);
@@ skipping 607 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // good0 re-enabled, other remain as they were.
   EXPECT_TRUE(enabled_extensions.Contains(good0));
   EXPECT_FALSE(disabled_extensions.Contains(good0));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
   EXPECT_TRUE(disabled_extensions.Contains(good1));
   EXPECT_TRUE(enabled_extensions.Contains(good2));
   EXPECT_FALSE(disabled_extensions.Contains(good2));
 }
+
+// Tests that blacklisted extensions cannot be reloaded, both those loaded
+// before and after extension service startup.
+TEST_F(ExtensionServiceTest, ReloadBlacklistedExtension) {
+  extensions::TestBlacklist test_blacklist;
+
+  InitializeGoodInstalledExtensionService();
+  test_blacklist.Attach(service_->blacklist_);
+
+  test_blacklist.SetBlacklistState(
+      good1, extensions::BLACKLISTED_MALWARE, false);
+  service_->Init();
+  test_blacklist.SetBlacklistState(
+      good2, extensions::BLACKLISTED_MALWARE, false);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(StringSet(good0), registry_->enabled_extensions().GetIDs());
+  EXPECT_EQ(StringSet(good1, good2),
+            registry_->blacklisted_extensions().GetIDs());
+
+  service_->ReloadExtension(good1);
+  service_->ReloadExtension(good2);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(StringSet(good0), registry_->enabled_extensions().GetIDs());
+  EXPECT_EQ(StringSet(good1, good2),
+            registry_->blacklisted_extensions().GetIDs());
+}
+
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionService();
 
   // Blacklist everything.
   {
     ListPrefUpdate update(profile_->GetPrefs(),
                           extensions::pref_names::kInstallDenyList);
@@ skipping 3319 matching lines @@
 
   service_->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                     content::Source<Profile>(profile_.get()),
                     content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry_->enabled_extensions().size());
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
   EXPECT_EQ(0u, registry_->terminated_extensions().size());
   EXPECT_EQ(0u, registry_->blacklisted_extensions().size());
 }