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

chrome/browser/extensions/extension_service.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.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 396 matching lines @@
     int update_frequency = kDefaultUpdateFrequencySeconds;
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       base::StringToInt(command_line->GetSwitchValueASCII(
           switches::kExtensionsUpdateFrequency),
           &update_frequency);
     }
     updater_.reset(new extensions::ExtensionUpdater(this,
                                                     extension_prefs,
                                                     profile->GetPrefs(),
                                                     profile,
-                                                    blacklist,
                                                     update_frequency));
   }
 
   component_loader_.reset(
       new extensions::ComponentLoader(this,
                                       profile->GetPrefs(),
                                       g_browser_process->local_state()));
 
   if (extensions_enabled_) {
     extensions::ExternalProviderImpl::CreateExternalProviders(
@@ skipping 2660 matching lines @@
   }
 }
 
 void ExtensionService::OnNeedsToGarbageCollectIsolatedStorage() {
   extension_prefs_->SetNeedsStorageGarbageCollection(true);
 }
 
 void ExtensionService::OnBlacklistUpdated() {
   blacklist_->GetBlacklistedIDs(
       GenerateInstalledExtensionsSet()->GetIDs(),
-      base::Bind(&ExtensionService::ManageBlacklist,
-                 AsWeakPtr(),
-                 blacklisted_extensions_.GetIDs()));
+      base::Bind(&ExtensionService::ManageBlacklist, AsWeakPtr()));
 }
 
-void ExtensionService::ManageBlacklist(
-    const std::set<std::string>& old_blacklisted_ids,
-    const std::set<std::string>& new_blacklisted_ids) {
+void ExtensionService::ManageBlacklist(const std::set<std::string>& updated) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  std::set<std::string> before = blacklisted_extensions_.GetIDs();
   std::set<std::string> no_longer_blacklisted =
-      base::STLSetDifference<std::set<std::string> >(old_blacklisted_ids,
-                                                     new_blacklisted_ids);
+      base::STLSetDifference<std::set<std::string> >(before, updated);
   std::set<std::string> not_yet_blacklisted =
-      base::STLSetDifference<std::set<std::string> >(new_blacklisted_ids,
-                                                     old_blacklisted_ids);
+      base::STLSetDifference<std::set<std::string> >(updated, before);
 
   for (std::set<std::string>::iterator it = no_longer_blacklisted.begin();
        it != no_longer_blacklisted.end(); ++it) {
     scoped_refptr<const Extension> extension =
         blacklisted_extensions_.GetByID(*it);
-    DCHECK(extension.get()) << "Extension " << *it << " no longer blacklisted, "
-                            << "but it was never blacklisted.";
-    if (!extension.get())
+    if (!extension.get()) {
+      NOTREACHED() << "Extension " << *it << " no longer blacklisted, "
+                   << "but it was never blacklisted.";
       continue;
+    }
     blacklisted_extensions_.Remove(*it);
+    extension_prefs_->SetExtensionBlacklisted(extension->id(), false);
     AddExtension(extension.get());
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.UnblacklistInstalled",
                               extension->location(),
                               Manifest::NUM_LOCATIONS);
   }
 
   for (std::set<std::string>::iterator it = not_yet_blacklisted.begin();
        it != not_yet_blacklisted.end(); ++it) {
     scoped_refptr<const Extension> extension = GetInstalledExtension(*it);
-    DCHECK(extension.get()) << "Extension " << *it << " needs to be "
-                            << "blacklisted, but it's not installed.";
-    if (!extension.get())
+    if (!extension.get()) {
+      NOTREACHED() << "Extension " << *it << " needs to be "
+                   << "blacklisted, but it's not installed.";
       continue;
+    }
     blacklisted_extensions_.Insert(extension);
+    extension_prefs_->SetExtensionBlacklisted(extension->id(), true);
     UnloadExtension(*it, extension_misc::UNLOAD_REASON_BLACKLIST);
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlacklistInstalled",
                               extension->location(), Manifest::NUM_LOCATIONS);
   }
 
   IdentifyAlertableExtensions();
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }