Do not load extension system in the Profile import process.

chrome/browser/extensions/component_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/component_loader.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/path_service.h"
@@ skipping 70 matching lines @@
   pref_change_registrar_.Add(
       prefs::kEnterpriseWebStoreURL,
       base::Bind(&ComponentLoader::AddOrReloadEnterpriseWebStore,
                  base::Unretained(this)));
 }
 
 ComponentLoader::~ComponentLoader() {
   ClearAllRegistered();
 }
 
-void ComponentLoader::LoadAll() {
+void ComponentLoader::BulkLoadAll() {
   for (RegisteredComponentExtensions::iterator it =
           component_extensions_.begin();
       it != component_extensions_.end(); ++it) {
-    Load(*it);
+    Load(*it, false);
   }
 }
 
+void ComponentLoader::BulkLoadDeferBackgroundPages() {
+  for (RegisteredComponentExtensions::iterator it =
+          component_extensions_.begin();
+      it != component_extensions_.end(); ++it) {
+    Load(*it, true);
+  }
+}
+
+void ComponentLoader::BulkLoadDeferred() {
+  for (DeferredAtLoadExtensions::iterator it =
+          deferred_at_load_extensions.begin();
+      it != deferred_at_load_extensions.end(); ++it) {
+    extension_service_->AddComponentExtension(*it);
+  }
+  deferred_at_load_extensions.clear();
+}
+
 DictionaryValue* ComponentLoader::ParseManifest(
     const std::string& manifest_contents) const {
   JSONStringValueSerializer serializer(manifest_contents);
   scoped_ptr<Value> manifest(serializer.Deserialize(NULL, NULL));
 
   if (!manifest.get() || !manifest->IsType(Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "Failed to parse extension manifest.";
     return NULL;
   }
   // Transfer ownership to the caller.
@@ skipping 26 matching lines @@
   if (manifest)
     return Add(manifest, root_directory);
   return "";
 }
 
 std::string ComponentLoader::Add(const DictionaryValue* parsed_manifest,
                                  const FilePath& root_directory) {
   ComponentExtensionInfo info(parsed_manifest, root_directory);
   component_extensions_.push_back(info);
   if (extension_service_->is_ready())
-    Load(info);
+    Load(info, false);
   return info.extension_id;
 }
 
 std::string ComponentLoader::AddOrReplace(const FilePath& path) {
   FilePath absolute_path = path;
   file_util::AbsolutePath(&absolute_path);
   std::string error;
   scoped_ptr<DictionaryValue> manifest(
       extension_file_util::LoadManifest(absolute_path, &error));
   if (!manifest.get()) {
     LOG(ERROR) << "Could not load extension from '" <<
                   absolute_path.value() << "'. " << error;
     return NULL;
   }
   Remove(GenerateId(manifest.get(), absolute_path));
 
   return Add(manifest.release(), absolute_path);
 }
 
 void ComponentLoader::Reload(const std::string& extension_id) {
   for (RegisteredComponentExtensions::iterator it =
          component_extensions_.begin(); it != component_extensions_.end();
          ++it) {
     if (it->extension_id == extension_id) {
-      Load(*it);
+      Load(*it, false);
       break;
     }
   }
 }
 
-const Extension* ComponentLoader::Load(const ComponentExtensionInfo& info) {
+void ComponentLoader::Load(const ComponentExtensionInfo& info,
+                           bool defer_if_has_background_page) {
   // TODO(abarth): We should REQUIRE_MODERN_MANIFEST_VERSION once we've updated
   //               our component extensions to the new manifest version.
   int flags = Extension::REQUIRE_KEY;
 
   std::string error;
 
   scoped_refptr<const Extension> extension(Extension::Create(
       info.root_directory,
       Extension::COMPONENT,
       *info.manifest,
       flags,
       &error));
   if (!extension.get()) {
     LOG(ERROR) << error;
-    return NULL;
+    return;
   }
+
   CHECK_EQ(info.extension_id, extension->id()) << extension->name();
-  extension_service_->AddComponentExtension(extension);
-  return extension;
+  if (extension->has_background_page() && defer_if_has_background_page) {
+    deferred_at_load_extensions.push_back(extension);
+  } else {
+    extension_service_->AddComponentExtension(extension);
+  }
 }
 
 void ComponentLoader::RemoveAll() {
   RegisteredComponentExtensions::iterator it = component_extensions_.begin();
   for (; it != component_extensions_.end(); ++it)
     UnloadComponent(&(*it));
 
   component_extensions_.clear();
 }
 
@@ skipping 224 matching lines @@
 void ComponentLoader::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreURL,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreName,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions