Adds async interface method to PersistentPrefStore.

chrome/browser/prefs/pref_value_store.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_value_store.h"
 
 #include "chrome/browser/prefs/pref_notifier.h"
 
 PrefValueStore::PrefStoreKeeper::PrefStoreKeeper()
     : pref_value_store_(NULL),
@@ skipping 19 matching lines @@
   pref_store_ = pref_store;
   if (pref_store_.get())
     pref_store_->AddObserver(this);
 }
 
 void PrefValueStore::PrefStoreKeeper::OnPrefValueChanged(
     const std::string& key) {
   pref_value_store_->OnPrefValueChanged(type_, key);
 }
 
-void PrefValueStore::PrefStoreKeeper::OnInitializationCompleted() {
-  pref_value_store_->OnInitializationCompleted(type_);
+void PrefValueStore::PrefStoreKeeper::OnInitializationCompleted(
+    bool succeeded) {
+  pref_value_store_->OnInitializationCompleted(type_, succeeded);
 }
 
 PrefValueStore::PrefValueStore(PrefStore* managed_platform_prefs,
                                PrefStore* managed_cloud_prefs,
                                PrefStore* extension_prefs,
                                PrefStore* command_line_prefs,
                                PrefStore* user_prefs,
                                PrefStore* recommended_platform_prefs,
                                PrefStore* recommended_cloud_prefs,
                                PrefStore* default_prefs,
@@ skipping 179 matching lines @@
   *out_value = NULL;
   return false;
 }
 
 void PrefValueStore::OnPrefValueChanged(PrefValueStore::PrefStoreType type,
                                         const std::string& key) {
   NotifyPrefChanged(key.c_str(), type);
 }
 
 void PrefValueStore::OnInitializationCompleted(
-    PrefValueStore::PrefStoreType type) {
+    PrefValueStore::PrefStoreType type, bool succeeded) {
+  if (!succeeded) {

[Mattias Nissler (ping if slow), 2011/05/04 23:33:08]

There's a problem here: If you have a PrefStore reporting initialization failed
and afterwards some other store reports successful initialization, you'll first
report the failure and then success. I think the fix is to introduce some flag
here, or make the PrefStoreKeeper keep a status flag.

[altimofeev, 2011/05/05 12:59:28]

Actually, to prevent it, IsInitializationComplete() returns false in case when
OnInitializationCompleted was called with "false" (initialization unsucceeded).

[Mattias Nissler (ping if slow), 2011/05/07 00:24:14]

But then IsInitializationComplete() is a misnomer, since it did complete, just
not successfully. Note that PrefService can still work perfectly fine, e.g. if
the file was corrupt, so I think it makes sense to be able to distinguish
between initialization done and failures. Long story short: I think the correct
behavior would be to have IsInitializationComplete() return true when init is
done, even if there is an error.

[altimofeev, 2011/05/10 11:10:22]

Agree, misnomer is no good. So now PrevValueStore stores whether one of the
PrefStores has failed initialization, and if it is the case, only one
OnInitializaionCompleted(false) is called.

+    pref_notifier_->OnInitializationCompleted(false);
+    return;
+  }
   CheckInitializationCompleted();
 }
 
 void PrefValueStore::InitPrefStore(PrefValueStore::PrefStoreType type,
                                    PrefStore* pref_store) {
   pref_stores_[type].Initialize(this, pref_store, type);
 }
 
 void PrefValueStore::CheckInitializationCompleted() {
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
     scoped_refptr<PrefStore> store =
         GetPrefStore(static_cast<PrefStoreType>(i));
     if (store && !store->IsInitializationComplete())
       return;
   }
-  pref_notifier_->OnInitializationCompleted();
+  pref_notifier_->OnInitializationCompleted(true);
 }