Adds async interface method to PersistentPrefStore.

chrome/browser/profiles/profile_impl.cc

 // Copyright (c) 2011 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/profiles/profile_impl.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
@@ skipping 269 matching lines @@
 #endif
       shutdown_session_service_(false),
       delegate_(delegate) {
   DCHECK(!path.empty()) << "Using an empty path will attempt to write " <<
                             "profile files to the root directory!";
   create_session_service_timer_.Start(
       TimeDelta::FromMilliseconds(kCreateSessionServiceDelayMS), this,
       &ProfileImpl::EnsureSessionServiceCreated);
 
   if (delegate_) {
-    prefs_.reset(PrefService::CreatePrefServiceAsync(
+    // Wait for the notifcation that prefs has been loaded (successfully or
+    // not).
+    registrar_.Add(this, NotificationType::PREF_INITIALIZATION_COMPLETED,
+                   Source<Profile>(this));
+    registrar_.Add(this, NotificationType::PREF_INITIALIZATION_FAILED,
+                   Source<Profile>(this));
+    prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         new ExtensionPrefStore(GetExtensionPrefValueMap(), false),
         GetOriginalProfile(),
-        this));  // Ask to notify us in the end.
+        true));
   } else {
     // Load prefs synchronously.
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         new ExtensionPrefStore(GetExtensionPrefValueMap(), false),
-        GetOriginalProfile()));
-    OnPrefsLoaded(prefs_.get(), true);
+        GetOriginalProfile(),
+        false));
+    OnPrefsLoaded(true);
   }
 }
 
 void ProfileImpl::DoFinalInit() {
   PrefService* prefs = GetPrefs();
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kSpellCheckDictionary, this);
   pref_change_registrar_.Add(prefs::kEnableSpellCheck, this);
   pref_change_registrar_.Add(prefs::kEnableAutoSpellCorrect, this);
   pref_change_registrar_.Add(prefs::kClearSiteDataOnExit, this);
@@ skipping 478 matching lines @@
     transport_security_state_ = new net::TransportSecurityState();
     transport_security_persister_ =
         new TransportSecurityPersister(false /* read-write */);
     transport_security_persister_->Initialize(
         transport_security_state_.get(), path_);
   }
 
   return transport_security_state_.get();
 }
 
-void ProfileImpl::OnPrefsLoaded(PrefService* prefs, bool success) {
-  DCHECK(prefs == prefs_.get());
-
+void ProfileImpl::OnPrefsLoaded(bool success) {
   if (!success) {
     DCHECK(delegate_);
     delegate_->OnProfileCreated(this, false);
     return;
   }
 
   // The Profile class and ProfileManager class may read some prefs so
   // register known prefs as soon as possible.
   Profile::RegisterUserPrefs(prefs_.get());
   browser::RegisterUserPrefs(prefs_.get());
@@ skipping 497 matching lines @@
 
     // NOTE: If you change what thread this writes on, be sure and update
     // ChromeFrame::EndSession().
     prefs_->SavePersistentPrefs();
   }
 }
 
 void ProfileImpl::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
-  if (NotificationType::PREF_CHANGED == type) {
-    std::string* pref_name_in = Details<std::string>(details).ptr();
-    PrefService* prefs = Source<PrefService>(source).ptr();
-    DCHECK(pref_name_in && prefs);
-    if (*pref_name_in == prefs::kSpellCheckDictionary ||
-        *pref_name_in == prefs::kEnableSpellCheck) {
-      ReinitializeSpellCheckHost(true);
-    } else if (*pref_name_in == prefs::kEnableAutoSpellCorrect) {
-      NotificationService::current()->Notify(
-          NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED,
-              Source<Profile>(this), NotificationService::NoDetails());
-    } else if (*pref_name_in == prefs::kClearSiteDataOnExit) {
-      clear_local_state_on_exit_ =
-          prefs->GetBoolean(prefs::kClearSiteDataOnExit);
-      if (webkit_context_) {
-        webkit_context_->set_clear_local_state_on_exit(
-            clear_local_state_on_exit_);
+  bool initialization_succeeded = true;
+  switch (type.value) {
+    case NotificationType::PREF_INITIALIZATION_FAILED:
+      initialization_succeeded = false;
+      // Fall through.
+    case NotificationType::PREF_INITIALIZATION_COMPLETED:
+      registrar_.Remove(this, NotificationType::PREF_INITIALIZATION_COMPLETED,
+                        Source<Profile>(this));
+      registrar_.Remove(this, NotificationType::PREF_INITIALIZATION_FAILED,
+                        Source<Profile>(this));
+      OnPrefsLoaded(initialization_succeeded);
+      break;
+    case NotificationType::PREF_CHANGED: {
+      std::string* pref_name_in = Details<std::string>(details).ptr();
+      PrefService* prefs = Source<PrefService>(source).ptr();
+      DCHECK(pref_name_in && prefs);
+      if (*pref_name_in == prefs::kSpellCheckDictionary ||
+          *pref_name_in == prefs::kEnableSpellCheck) {
+        ReinitializeSpellCheckHost(true);
+      } else if (*pref_name_in == prefs::kEnableAutoSpellCorrect) {
+        NotificationService::current()->Notify(
+            NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED,
+                Source<Profile>(this), NotificationService::NoDetails());
+      } else if (*pref_name_in == prefs::kClearSiteDataOnExit) {
+        clear_local_state_on_exit_ =
+            prefs->GetBoolean(prefs::kClearSiteDataOnExit);
+        if (webkit_context_) {
+          webkit_context_->set_clear_local_state_on_exit(
+              clear_local_state_on_exit_);
+        }
+        if (appcache_service_) {
+          appcache_service_->SetClearLocalStateOnExit(
+              clear_local_state_on_exit_);
+        }
       }
-      if (appcache_service_) {
-        appcache_service_->SetClearLocalStateOnExit(
-            clear_local_state_on_exit_);
-      }
+      break;
     }
-  } else if (NotificationType::BOOKMARK_MODEL_LOADED == type) {
-    GetProfileSyncService();  // Causes lazy-load if sync is enabled.
-    registrar_.Remove(this, NotificationType::BOOKMARK_MODEL_LOADED,
-                      Source<Profile>(this));
+    case NotificationType::BOOKMARK_MODEL_LOADED:
+      GetProfileSyncService();  // Causes lazy-load if sync is enabled.
+      registrar_.Remove(this, NotificationType::BOOKMARK_MODEL_LOADED,
+                        Source<Profile>(this));
+      break;
+    default:
+      NOTREACHED();
   }
 }
 
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 TokenService* ProfileImpl::GetTokenService() {
   if (!token_service_.get()) {
     token_service_.reset(new TokenService());
@@ skipping 206 matching lines @@
   return pref_proxy_config_tracker_;
 }
 
 prerender::PrerenderManager* ProfileImpl::GetPrerenderManager() {
   if (!prerender::PrerenderManager::IsPrerenderingPossible())
     return NULL;
   if (!prerender_manager_.get())
     prerender_manager_.reset(new prerender::PrerenderManager(this));
   return prerender_manager_.get();
 }