Adds async interface method to PersistentPrefStore.

chrome/browser/prefs/pref_service.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.
 
 // This provides a way to access the application's current preferences.
 
 #ifndef CHROME_BROWSER_PREFS_PREF_SERVICE_H_
 #define CHROME_BROWSER_PREFS_PREF_SERVICE_H_
 #pragma once
 
@@ skipping 23 matching lines @@
 };
 
 class PrefService;
 
 class PrefServiceDelegate {
  public:
   virtual void OnPrefsLoaded(PrefService* prefs, bool success) = 0;
 };
 
 class PrefService : public base::NonThreadSafe,
-                    public JsonPrefStore::Delegate {
+                    public PrefStore::Observer {
  public:
   // A helper class to store all the information associated with a preference.
   class Preference {
    public:
 
     // The type of the preference is determined by the type with which it is
     // registered. This type needs to be a boolean, integer, double, string,
     // dictionary (a branch), or list.  You shouldn't need to construct this on
     // your own; use the PrefService::Register*Pref methods instead.
     Preference(const PrefService* service,
@@ skipping 58 matching lines @@
     std::string name_;
 
     Value::ValueType type_;
 
     // Reference to the PrefService in which this pref was created.
     const PrefService* pref_service_;
 
     DISALLOW_COPY_AND_ASSIGN(Preference);
   };
 
-  // JsonPrefStore::Delegate implementaion.
-  virtual void OnPrefsRead(PersistentPrefStore::PrefReadError error,
-                           bool no_dir);
-
   // Factory method that creates a new instance of a PrefService with the
   // applicable PrefStores. The |pref_filename| points to the user preference
   // file. The |profile| is the one to which these preferences apply; it may be
   // NULL if we're dealing with the local state. This is the usual way to create
   // a new PrefService. |extension_pref_store| is used as the source for
   // extension-controlled preferences and may be NULL. The PrefService takes
   // ownership of |extension_pref_store|.
   static PrefService* CreatePrefService(const FilePath& pref_filename,
                                         PrefStore* extension_pref_store,
                                         Profile* profile);
@@ skipping 119 matching lines @@
   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);
 
+  // PrefStore::Observer implementation:
+  virtual void OnPrefValueChanged(const std::string&) {}
+  virtual void OnInitializationCompleted();
+
   // The PrefNotifier handles registering and notifying preference observers.
   // It is created and owned by this PrefService. Subclasses may access it for
   // unit testing.
   scoped_ptr<PrefNotifierImpl> pref_notifier_;
 
  private:
   class PreferencePathComparator {
    public:
     bool operator() (Preference* lhs, Preference* rhs) const {
       return lhs->name() < rhs->name();
@@ skipping 68 matching lines @@
   mutable PreferenceSet prefs_;
 
   // Holds delegator to be called after initialization, if async version
   // is used.
   PrefServiceDelegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_SERVICE_H_