Add a non-blocking "OneShotEvent" class

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 319 matching lines @@
 
   return true;
 }
 
 ExtensionService::ExtensionService(Profile* profile,
                                    const CommandLine* command_line,
                                    const base::FilePath& install_directory,
                                    extensions::ExtensionPrefs* extension_prefs,
                                    extensions::Blacklist* blacklist,
                                    bool autoupdate_enabled,
-                                   bool extensions_enabled)
+                                   bool extensions_enabled,
+                                   extensions::OneShotEvent* ready)
     : extensions::Blacklist::Observer(blacklist),
       profile_(profile),
       system_(extensions::ExtensionSystem::Get(profile)),
       extension_prefs_(extension_prefs),
       blacklist_(blacklist),
       settings_frontend_(extensions::SettingsFrontend::Create(profile)),
       pending_extension_manager_(*this),
       install_directory_(install_directory),
       extensions_enabled_(extensions_enabled),
       show_extensions_prompts_(true),
       install_updates_when_idle_(true),
-      ready_(false),
+      ready_(ready),
       toolbar_model_(this),
       menu_manager_(profile),
       event_routers_initialized_(false),
       update_once_all_providers_are_ready_(false),
       browser_terminating_(false),
       installs_delayed_(false),
       is_first_run_(false),
       app_sync_bundle_(this),
       extension_sync_bundle_(this) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 191 matching lines @@
     const Extension* extension = blacklisted_extensions_.GetByID(lowercase_id);
     if (extension)
       return extension;
   }
   return NULL;
 }
 
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DCHECK(!ready_);  // Can't redo init.
+  DCHECK(!is_ready());  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   CHECK(!ProfileManager::IsImportProcess(*cmd_line));
 
   if (cmd_line->HasSwitch(switches::kInstallFromWebstore) ||
       cmd_line->HasSwitch(switches::kLimitedInstallFromWebstore)) {
     // The sole purpose of this launch is to install a new extension from CWS
     // and immediately terminate: loading already installed extensions is
     // unnecessary and may interfere with the inline install dialog (e.g. if an
     // extension listens to onStartup and opens a window).
     SetReadyAndNotifyListeners();
   } else {
     // TODO(mek): It might be cleaner to do the FinishDelayedInstallInfo stuff
     // here instead of in installedloader.
     if (g_browser_process->profile_manager() &&
         g_browser_process->profile_manager()->will_import()) {
       // Do not load any component extensions, since they may conflict with the
       // import process.
 
       extensions::InstalledLoader(this).LoadAllExtensions();
+      SetReadyAndNotifyListeners();
       RegisterForImportFinished();
     } else {
-      // In this case, LoadAllExtensions() calls OnLoadedInstalledExtensions(),
-      // which calls SetReadyAndNotifyListeners().
+      // In this case, LoadAllExtensions() calls OnLoadedInstalledExtensions().
       component_loader_->LoadAll();
       extensions::InstalledLoader(this).LoadAllExtensions();
+      SetReadyAndNotifyListeners();
 
       // 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()) {
@@ skipping 624 matching lines @@
 
 extensions::SettingsFrontend* ExtensionService::settings_frontend() {
   return settings_frontend_.get();
 }
 
 extensions::ContentSettingsStore* ExtensionService::GetContentSettingsStore() {
   return extension_prefs()->content_settings_store();
 }
 
 bool ExtensionService::is_ready() {
-  return ready_;
+  return ready_->is_signaled();
 }
 
 base::SequencedTaskRunner* ExtensionService::GetFileTaskRunner() {
   if (file_task_runner_)
     return file_task_runner_;
 
   // We should be able to interrupt any part of extension install process during
   // shutdown. SKIP_ON_SHUTDOWN ensures that not started extension install tasks
   // will be ignored/deleted while we will block on started tasks.
   std::string token("ext_install-");
@@ skipping 703 matching lines @@
 
   // 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();
   extensions::InstalledLoader(this).LoadAllExtensions();
+  // Don't call SetReadyAndNotifyListeners() since tests call this multiple
+  // times.
 }
 
 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
     // again later.
@@ skipping 38 matching lines @@
 
 void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
   if (app_sync_bundle_.HandlesApp(extension)) {
     app_sync_bundle_.SyncChangeIfNeeded(extension);
   } else if (extension_sync_bundle_.HandlesExtension(extension)) {
     extension_sync_bundle_.SyncChangeIfNeeded(extension);
   }
 }
 
 void ExtensionService::SetReadyAndNotifyListeners() {
-  ready_ = true;
+  ready_->Signal();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSIONS_READY,
       content::Source<Profile>(profile_),
       content::NotificationService::NoDetails());
 }
 
 void ExtensionService::OnLoadedInstalledExtensions() {
   if (updater_)
     updater_->Start();
 
   OnBlacklistUpdated();
-
-  SetReadyAndNotifyListeners();
 }
 
 void ExtensionService::AddExtension(const Extension* extension) {
   // TODO(jstritar): We may be able to get rid of this branch by overriding the
   // default extension state to DISABLED when the --disable-extensions flag
   // is set (http://crbug.com/29067).
   if (!extensions_enabled() &&
       !extension->is_theme() &&
       extension->location() != Manifest::COMPONENT &&
       !Manifest::IsExternalLocation(extension->location())) {
@@ skipping 1067 matching lines @@
 }
 
 void ExtensionService::AddUpdateObserver(extensions::UpdateObserver* observer) {
   update_observers_.AddObserver(observer);
 }
 
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }