Adds async interface method to PersistentPrefStore.

chrome/common/persistent_pref_store.h

 // 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.
 
 #ifndef CHROME_COMMON_PERSISTENT_PREF_STORE_H_
 #define CHROME_COMMON_PERSISTENT_PREF_STORE_H_
 #pragma once
 
 #include <string>
 
@@ skipping 16 matching lines @@
     PREF_READ_ERROR_JSON_TYPE,
     PREF_READ_ERROR_ACCESS_DENIED,
     PREF_READ_ERROR_FILE_OTHER,
     PREF_READ_ERROR_FILE_LOCKED,
     PREF_READ_ERROR_NO_FILE,
     PREF_READ_ERROR_JSON_REPEAT,
     PREF_READ_ERROR_OTHER,
     PREF_READ_ERROR_FILE_NOT_SPECIFIED
   };
 
+  class ReadErrorDelegate {
+   public:
+    virtual ~ReadErrorDelegate() {}
+
+    virtual void OnError(PrefReadError error) = 0;
+  };
+
   // Equivalent to PrefStore::GetValue but returns a mutable value.
   virtual ReadResult GetMutableValue(const std::string& key,
                                      Value** result) = 0;
 
   // Triggers a value changed notification. This function needs to be called
   // if one retrieves a list or dictionary with GetMutableValue and change its
   // value. SetValue takes care of notifications itself. Note that
   // ReportValueChanged will trigger notifications even if nothing has changed.
   virtual void ReportValueChanged(const std::string& key) = 0;
 
   // Sets a |value| for |key| in the store. Assumes ownership of |value|, which
   // must be non-NULL.
   virtual void SetValue(const std::string& key, Value* value) = 0;
 
   // Same as SetValue, but doesn't generate notifications. This is used by
   // PrefService::GetMutableUserPref() in order to put empty entries
   // into the user pref store. Using SetValue is not an option since existing
   // tests rely on the number of notifications generated.
   virtual void SetValueSilently(const std::string& key, Value* value) = 0;
 
   // Removes the value for |key|.
   virtual void RemoveValue(const std::string& key) = 0;
 
   // Whether the store is in a pseudo-read-only mode where changes are not
   // actually persisted to disk.  This happens in some cases when there are
   // read errors during startup.
   virtual bool ReadOnly() const = 0;
 
-  // Reads the preferences from disk.
+  // Reads the preferences from disk. Notifies observers via
+  // "PrefStore::OnInitializationCompleted" when done.
   virtual PrefReadError ReadPrefs() = 0;
 
+  // Reads the preferences from disk asynchronously. Notifies observers via
+  // "PrefStore::OnInitializationCompleted" when done. Also it fires

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

So we still have two callback mechanisms? Seems like this is a hassle to
implementors. Can't we just make OnInitializationCompleted take a PrefReadError
parameter? And move the error handling code from PrefService to
PrefNotifierImpl?

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

Yes, there are two of them. But the only reason why ReadErrorDelegate was
created was that JsonPrefService can't handle error (show notification etc). So
owner of JsonPrefService provides this delegate to extend JsonPrefService if
this extensions is needed. At the same time, OnInitializationCompleted() is
general interface for all PrefStores, not only the ones which read initial data
from the file. It brings us to my first objection - OnInitializationCompleted()
is part of the PrefStore, not PersistentPrefStore. My second objection is that
moving error handling to PrefNotifierImpl implies passing error through the
chain - JsonPrefStore => PrefStoreKeeper => PrefValueStore =>
PrefNotificationImpl.

Note, in the future, if this interface will be broadly used, one can make
ReadErrorHandler public to be used by other PersistentPrefs clients.

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

You are very right, in this case it makes sense to have two callback mechanisms,
since we don't want to pollute the PrefStore interface with PersistentPrefStore
stuff. Sorry for not thinking it through when writing the first comment.

+  // |error_delegate| if it is not NULL and reading error has occurred.
+  // Owns |error_delegate|.
+  virtual void ReadPrefsAsync(ReadErrorDelegate* error_delegate) = 0;
+
   // Writes the preferences to disk immediately.
   virtual bool WritePrefs() = 0;
 
   // Schedules an asynchronous write operation.
   virtual void ScheduleWritePrefs() = 0;
 
   // Lands any pending writes to disk.
   virtual void CommitPendingWrite() = 0;
 };
 
 #endif  // CHROME_COMMON_PERSISTENT_PREF_STORE_H_