Do not load extension system in the Profile import process.

chrome/browser/extensions/extension_service.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.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 394 matching lines @@
   }
 
   component_loader_.reset(
       new extensions::ComponentLoader(this,
                                       profile->GetPrefs(),
                                       g_browser_process->local_state()));
 
   app_notification_manager_->Init();
 
   if (extensions_enabled_) {
-    if (!command_line->HasSwitch(switches::kImport) &&
-        !command_line->HasSwitch(switches::kImportFromFile)) {
-      extensions::ExternalProviderImpl::CreateExternalProviders(
-          this, profile_, &external_extension_providers_);
-    }
+    CHECK(!ProfileManager::IsImportProcess(*command_line));
+    extensions::ExternalProviderImpl::CreateExternalProviders(
+        this, profile_, &external_extension_providers_);
   }
 
   // Set this as the ExtensionService for extension sorting to ensure it
   // cause syncs if required.
   extension_prefs_->extension_sorting()->SetExtensionService(this);
 
 #if defined(ENABLE_EXTENSIONS)
   extension_action_storage_manager_.reset(
       new extensions::ExtensionActionStorageManager(profile_));
 #endif
@@ skipping 67 matching lines @@
 
 void ExtensionService::RegisterForImportFinished() {
   if (!registrar_.IsRegistered(this, chrome::NOTIFICATION_IMPORT_FINISHED,
                                content::Source<Profile>(profile_))) {
     registrar_.Add(this, chrome::NOTIFICATION_IMPORT_FINISHED,
                    content::Source<Profile>(profile_));
   }
 }
 
 void ExtensionService::InitAfterImport() {
+  component_loader_->LoadAllDeferred();
+
   CheckForExternalUpdates();
 
   GarbageCollectExtensions();
 
   // Idempotent, so although there is a possible race if the import
   // process finished sometime in the middle of ProfileImpl::InitExtensions,
   // it cannot happen twice.
   InitEventRouters();
 }
 
@@ skipping 67 matching lines @@
   }
   return NULL;
 }
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
+  CHECK(!ProfileManager::IsImportProcess(*CommandLine::ForCurrentProcess()));
+
   // TODO(mek): It might be cleaner to do the FinishDelayedInstallInfo stuff
   // here instead of in installedloader.
-  component_loader_->LoadAll();
-  extensions::InstalledLoader(this).LoadAllExtensions();
+  if (g_browser_process->profile_manager() &&
+      g_browser_process->profile_manager()->will_import()) {
+
+    // Defer extensions with background pages, since they may conflict with the
+    // import process.
+    component_loader_->LoadAll(true);
+    extensions::InstalledLoader(this).LoadAllExtensions();

[tapted, 2012/12/19 13:19:14]

a question raised from this line might be, "what about user-installed extensions
with background pages?" There shouldn't (yet) be any installed extensions in a
"real" first-run/auto-import. So this line here should typically do nothing.
However, extensions (with background pages) installed via master_preferences
might be an exception.

[Yoyo Zhou, 2012/12/19 21:50:38]

If non-component extensions are not being deferred, then the comment should read
"defer component extensions".

[tapted, 2012/12/19 22:58:24]

Done.

+    RegisterForImportFinished();
+  } else {
+    component_loader_->LoadAll(false);
+    extensions::InstalledLoader(this).LoadAllExtensions();
+
+    // TODO(erikkay) this should probably be deferred to a future point
+    // rather than running immediately at startup.
+    CheckForExternalUpdates();
+
+    // TODO(erikkay) this should probably be deferred as well.
+    GarbageCollectExtensions();
+  }
 
   // The Sideload Wipeout effort takes place during load (see above), so once
   // that is done the flag can be set so that we don't have to check again.
   if (wipeout_is_active_) {
     extension_prefs_->SetSideloadWipeoutDone();
     wipeout_is_active_ = false;  // Wipeout is only on during load.
   }
 
-  // If we are running in the import process, don't bother initializing the
-  // extension service since this can interfere with the main browser process
-  // that is already running an extension service for this profile.
-  // TODO(aa): can we start up even less of ExtensionService?
-  // http://crbug.com/107636
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kImport) &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(switches::kImportFromFile)) {
-    if (g_browser_process->profile_manager() &&
-        g_browser_process->profile_manager()->will_import()) {
-      RegisterForImportFinished();
-    } else {
-      // TODO(erikkay) this should probably be deferred to a future point
-      // rather than running immediately at startup.
-      CheckForExternalUpdates();
-
-      // TODO(erikkay) this should probably be deferred as well.
-      GarbageCollectExtensions();
-    }
-  }
-
   if (extension_prefs_->NeedsStorageGarbageCollection()) {
     GarbageCollectIsolatedStorage();
     extension_prefs_->SetNeedsStorageGarbageCollection(false);
   }
 }
 
 bool ExtensionService::UpdateExtension(const std::string& id,
                                        const FilePath& extension_path,
                                        const GURL& download_url,
                                        CrxInstaller** out_crx_installer) {
@@ skipping 1372 matching lines @@
   terminated_extensions_.Clear();
   extension_runtime_data_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionService::ReloadExtensions() {
   UnloadAllExtensions();
-  component_loader_->LoadAll();
+  component_loader_->LoadAll(false);
   extensions::InstalledLoader(this).LoadAllExtensions();
 }
 
 void ExtensionService::GarbageCollectExtensions() {
   if (extension_prefs_->pref_service()->ReadOnly())
     return;
 
   if (pending_extension_manager()->HasPendingExtensions()) {
     // Don't garbage collect while there are pending installations, which may
     // be using the temporary installation directory. Try to garbage collect
@@ skipping 1120 matching lines @@
     scoped_refptr<const Extension> extension = GetInstalledExtension(*it);
     DCHECK(extension);
     if (!extension)
       continue;
     blacklisted_extensions_.Insert(extension);
     UnloadExtension(*it, extension_misc::UNLOAD_REASON_BLACKLIST);
   }
 
   IdentifyAlertableExtensions();
 }