Sanity tweaks to the extension blacklist: check all extensions at once on

chrome/browser/extensions/installed_loader.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/installed_loader.h"
 
 #include "base/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 70 matching lines @@
 namespace extensions {
 
 InstalledLoader::InstalledLoader(ExtensionService* extension_service)
     : extension_service_(extension_service),
       extension_prefs_(extension_service->extension_prefs()) {
 }
 
 InstalledLoader::~InstalledLoader() {
 }
 
-void InstalledLoader::Load(const ExtensionInfo& info, bool write_to_prefs) {
+scoped_refptr<const Extension> InstalledLoader::Load(const ExtensionInfo& info,
+                                                     bool write_to_prefs) {
   std::string error;
   scoped_refptr<const Extension> extension(NULL);
   if (info.extension_manifest.get()) {
     extension = Extension::Create(
         info.extension_path,
         info.extension_location,
         *info.extension_manifest,
         GetCreationFlags(&info),
         &error);
   } else {
@@ skipping 19 matching lines @@
       !policy->UserMayLoad(extension, NULL)) {
     // The error message from UserMayInstall() often contains the extension ID
     // and is therefore not well suited to this UI.
     error = errors::kDisabledByPolicy;
     extension = NULL;
   }
 
   if (!extension) {
     extension_service_->
         ReportExtensionLoadError(info.extension_path, error, false);
-    return;
+    return scoped_refptr<const Extension>();
   }
 
   if (write_to_prefs)
     extension_prefs_->UpdateManifest(extension);
 
-  extension_service_->AddExtension(extension);
+  return extension;
 }
 
 void InstalledLoader::LoadAllExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
@@ skipping 57 matching lines @@
         continue;
       }
 
       extensions_info->at(i)->extension_manifest.reset(
           static_cast<DictionaryValue*>(
               extension->manifest()->value()->DeepCopy()));
       should_write_prefs = true;
     }
   }
 
+  std::vector<scoped_refptr<const Extension> > loaded_extensions;
   for (size_t i = 0; i < extensions_info->size(); ++i) {
-    Load(*extensions_info->at(i), should_write_prefs);
+    scoped_refptr<const Extension> loaded_extension =
+        Load(*extensions_info->at(i), should_write_prefs);
+    if (loaded_extension)
+      loaded_extensions.push_back(loaded_extension);
   }
 
+  extension_service_->AddExtensions(loaded_extensions);
   extension_service_->OnLoadedInstalledExtensions();
 
   // The histograms Extensions.ManifestReload* allow us to validate
   // the assumption that reloading manifest is a rare event.
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNotNeeded",
                            reload_reason_counts[NOT_NEEDED]);
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadUnpackedDir",
                            reload_reason_counts[UNPACKED_DIR]);
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNeedsRelocalization",
                            reload_reason_counts[NEEDS_RELOCALIZATION]);
@@ skipping 142 matching lines @@
 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
   int flags = extension_prefs_->GetCreationFlags(info->extension_id);
   if (info->extension_location != Manifest::LOAD)
     flags |= Extension::REQUIRE_KEY;
   if (extension_prefs_->AllowFileAccess(info->extension_id))
     flags |= Extension::ALLOW_FILE_ACCESS;
   return flags;
 }
 
 }  // namespace extensions