Adds async interface method to PersistentPrefStore.

chrome/browser/prefs/pref_service.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/prefs/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 68 matching lines @@
 // MessageLoop to run.
 void NotifyReadError(PrefService* pref, int message_id) {
   ShowProfileErrorDialog(message_id);
 }
 
 }  // namespace
 
 // static
 PrefService* PrefService::CreatePrefService(const FilePath& pref_filename,
                                             PrefStore* extension_prefs,
-                                            Profile* profile) {
-  return CreatePrefServiceAsync(pref_filename, extension_prefs, profile, NULL);
-}
-
-// static
-PrefService* PrefService::CreatePrefServiceAsync(
-    const FilePath& pref_filename,
-    PrefStore* extension_prefs,
-    Profile* profile,
-    PrefServiceDelegate* delegate) {
+                                            Profile* profile,
+                                            bool async) {
   using policy::ConfigurationPolicyPrefStore;
 
 #if defined(OS_LINUX)
   // We'd like to see what fraction of our users have the preferences
   // stored on a network file system, as we've had no end of troubles
   // with NFS/AFS.
   // TODO(evanm): remove this once we've collected state.
   file_util::FileSystemType fstype;
   if (file_util::GetFileSystemType(pref_filename.DirName(), &fstype)) {
     UMA_HISTOGRAM_ENUMERATION("PrefService.FileSystemType",
@@ skipping 11 matching lines @@
   JsonPrefStore* user = new JsonPrefStore(
       pref_filename,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   ConfigurationPolicyPrefStore* recommended_platform =
       ConfigurationPolicyPrefStore::CreateRecommendedPlatformPolicyPrefStore();
   ConfigurationPolicyPrefStore* recommended_cloud =
       ConfigurationPolicyPrefStore::CreateRecommendedCloudPolicyPrefStore(
           profile);
   DefaultPrefStore* default_pref_store = new DefaultPrefStore();
 
-  return new PrefService(managed_platform, managed_cloud, extension_prefs,
-                         command_line, user, recommended_platform,
-                         recommended_cloud, default_pref_store, delegate);
+  PrefService* service = new PrefService(
+      managed_platform, managed_cloud, extension_prefs,
+      command_line, user, recommended_platform,
+      recommended_cloud, default_pref_store);
+  service->InitFromStorage(async);
+  return service;
 }
 
 PrefService* PrefService::CreateIncognitoPrefService(
     PrefStore* incognito_extension_prefs) {
-  return new PrefService(*this, incognito_extension_prefs);
+  PrefService* service = new PrefService(*this, incognito_extension_prefs);
+  service->InitFromStorage(false);
+  return service;
 }
 
 PrefService::PrefService(PrefStore* managed_platform_prefs,
                          PrefStore* managed_cloud_prefs,
                          PrefStore* extension_prefs,
                          PrefStore* command_line_prefs,
                          PersistentPrefStore* user_prefs,
                          PrefStore* recommended_platform_prefs,
                          PrefStore* recommended_cloud_prefs,
-                         DefaultPrefStore* default_store,
-                         PrefServiceDelegate* delegate)
+                         DefaultPrefStore* default_store)
     : user_pref_store_(user_prefs),
-      default_store_(default_store),
-      delegate_(delegate) {
+      default_store_(default_store) {
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(
       new PrefValueStore(managed_platform_prefs,
                          managed_cloud_prefs,
                          extension_prefs,
                          command_line_prefs,
                          user_pref_store_,
                          recommended_platform_prefs,
                          recommended_cloud_prefs,
                          default_store,
                          pref_notifier_.get()));
-  InitFromStorage();
 }
 
 PrefService::PrefService(const PrefService& original,
                          PrefStore* incognito_extension_prefs)
       : user_pref_store_(
             new OverlayPersistentPrefStore(original.user_pref_store_.get())),
-        default_store_(original.default_store_.get()),
-        delegate_(NULL) {
+        default_store_(original.default_store_.get())  {
   pref_notifier_.reset(new PrefNotifierImpl(this));
   pref_value_store_.reset(original.pref_value_store_->CloneAndSpecialize(
       NULL, // managed_platform_prefs
       NULL, // managed_cloud_prefs
       incognito_extension_prefs,
       NULL, // command_line_prefs
       user_pref_store_.get(),
       NULL, // recommended_platform_prefs
       NULL, // recommended_cloud_prefs
       default_store_.get(),
       pref_notifier_.get()));
-  InitFromStorage();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
 
   // Reset pointers so accesses after destruction reliably crash.
   pref_value_store_.reset();
   user_pref_store_ = NULL;
   default_store_ = NULL;
 }
 
-void PrefService::OnPrefsRead(PersistentPrefStore::PrefReadError error,
-                              bool no_dir) {
-  if (no_dir) {
+void PrefService::OnInitializationCompleted() {
+  // This is the only message PrefService is waiting for, so remove us from the
+  // observers list.
+  user_pref_store_->RemoveObserver(this);
+
+  PersistentPrefStore::PrefReadError error;
+  bool is_fatal;
+  user_pref_store_->GetErrors(&error, &is_fatal);
+  if (is_fatal) {
     // Bad news. When profile is created, the process that creates the directory
     // is explicitly started. So if directory is missing it probably means that
     // Chromium hasn't sufficient privileges.
-    CHECK(delegate_);
-    delegate_->OnPrefsLoaded(this, false);
+    pref_notifier_->OnPersistentPrefsRead(false);
     return;
   }
 
   if (error != PersistentPrefStore::PREF_READ_ERROR_NONE) {
     // Failing to load prefs on startup is a bad thing(TM). See bug 38352 for
     // an example problem that this can cause.
     // Do some diagnosis and try to avoid losing data.
     int message_id = 0;
     if (error <= PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE) {
       message_id = IDS_PREFERENCES_CORRUPT_ERROR;
     } else if (error != PersistentPrefStore::PREF_READ_ERROR_NO_FILE) {
       message_id = IDS_PREFERENCES_UNREADABLE_ERROR;
     }
 
     if (message_id) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           NewRunnableFunction(&NotifyReadError, this, message_id));
     }
     UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error, 20);
   }
-
-  if (delegate_)
-    delegate_->OnPrefsLoaded(this, true);
+  pref_notifier_->OnPersistentPrefsRead(true);
 }
 
-void PrefService::InitFromStorage() {
-  if (!delegate_) {
-    const PersistentPrefStore::PrefReadError error =
-        user_pref_store_->ReadPrefs();
-    OnPrefsRead(error, false);
+void PrefService::InitFromStorage(bool async) {
+  user_pref_store_->AddObserver(this);
+  if (!async) {
+    user_pref_store_->ReadPrefs();
   } else {
-    // todo(altimofeev): move this method to PersistentPrefStore interface.
-    (static_cast<JsonPrefStore*>(user_pref_store_.get()))->ReadPrefs(this);
+    user_pref_store_.get()->ReadPrefsAsync();
   }
 }
 
 bool PrefService::ReloadPersistentPrefs() {
   return user_pref_store_->ReadPrefs() ==
              PersistentPrefStore::PREF_READ_ERROR_NONE;
 }
 
 bool PrefService::SavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
@@ skipping 451 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }