ExtensionService: Delay non-critical IO until after startup has finished.

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 <set>
 
 #include "base/basictypes.h"
@@ skipping 351 matching lines @@
       profile_(profile),
       system_(extensions::ExtensionSystem::Get(profile)),
       extension_prefs_(extension_prefs),
       settings_frontend_(extensions::SettingsFrontend::Create(profile)),
       pending_extension_manager_(*ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       install_directory_(install_directory),
       extensions_enabled_(extensions_enabled),
       show_extensions_prompts_(true),
       install_updates_when_idle_(true),
       ready_(false),
+      external_update_check_has_run_(false),
       toolbar_model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       menu_manager_(profile),
       app_notification_manager_(
           new extensions::AppNotificationManager(profile)),
       event_routers_initialized_(false),
       update_once_all_providers_are_ready_(false),
       browser_terminating_(false),
       app_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       extension_sync_bundle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       app_shortcut_manager_(profile) {
@@ skipping 222 matching lines @@
   // 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();
+      // For newly created profiles, check for external updates immediately.
+      // Otherwise delay the check until onload fires for the main frame, to
+      // speed up startup.
+      bool is_new_profile =
+          profile_->GetPrefs()->GetInitializationStatus() ==
+              PrefService::INITIALIZATION_STATUS_CREATED_NEW_PROFILE;
+      if (is_new_profile)
+        CheckForExternalUpdates();
 
-      // TODO(erikkay) this should probably be deferred as well.
-      GarbageCollectExtensions();
+      // Hook onload for the first frame to perform delayed startup actions.
+      // TODO(jeremy):If a generic mechanism is introduced to perform actions
+      // delayed until after startup finishes, use that rather than listening
+      // on the event ourselves.
+      registrar_.Add(this,
+                     content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+                     content::NotificationService::AllSources());
     }
   }
 }
 
 bool ExtensionService::UpdateExtension(const std::string& id,
                                        const FilePath& extension_path,
                                        const GURL& download_url,
                                        CrxInstaller** out_crx_installer) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (browser_terminating_) {
@@ skipping 1094 matching lines @@
 // are typically part of some larger client application package.  To support
 // these, the extension will register its location in the the preferences file
 // (and also, on Windows, in the registry) and this code will periodically
 // check that location for a .crx file, which it will then install locally if
 // a new version is available.
 // Errors are reported through ExtensionErrorReporter. Succcess is not
 // reported.
 void ExtensionService::CheckForExternalUpdates() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  // In the case of a new profile, this function is called at init time and then
+  // again when the first frame loads.  Short-circuit subsequent calls.
+  if (external_update_check_has_run_)
+    return;
+  external_update_check_has_run_ = true;
+
   // Note that this installation is intentionally silent (since it didn't
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
@@ skipping 937 matching lines @@
       // that other handlers of this notification will still have
       // access to the Extension and ExtensionHost.
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(
               &ExtensionService::TrackTerminatedExtension,
               AsWeakPtr(),
               host->extension()));
       break;
     }
+    case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME:
+      registrar_.Remove(
+          this,
+          content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+          content::NotificationService::AllSources());
+
+      CheckForExternalUpdates();
+      GarbageCollectExtensions();
+      break;
+
     case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
           break;
 
       // Extensions need to know the channel for API restrictions.
       process->Send(new ExtensionMsg_SetChannel(
@@ skipping 330 matching lines @@
         extension_id, kOnUpdateAvailableEvent);
   } else {
     // Delay installation if the extension is not idle.
     return !IsExtensionIdle(extension_id);
   }
 }
 
 void ExtensionService::OnBlacklistUpdated() {
   CheckManagementPolicy();
 }