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 17 matching lines @@
 class PrefValueStore;
 class Profile;
 
 namespace subtle {
 class PrefMemberBase;
 class ScopedUserPrefUpdateBase;
 };
 
 class PrefService;
 
-class PrefServiceDelegate {
- public:
-  virtual void OnPrefsLoaded(PrefService* prefs, bool success) = 0;
-};
-
-class PrefService : public base::NonThreadSafe,
-                    public JsonPrefStore::Delegate {
+class PrefService : public base::NonThreadSafe {
  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|.
+  // ownership of |extension_pref_store|. If |async| is true, asynchronous
+  // version is used. Notifies using PREF_INITIALIZATION_COMPLETED in the end.
+  // Details is set to the created PrefService or NULL if creation has failed.
+  // Note, it is guaranteed that in asynchronous version initialization happens
+  // after this function returned.
   static PrefService* CreatePrefService(const FilePath& pref_filename,
                                         PrefStore* extension_pref_store,
-                                        Profile* profile);
-
-  // Same as above, but with async initialization.
-  static PrefService* CreatePrefServiceAsync(const FilePath& pref_filename,
-                                             PrefStore* extension_pref_store,
-                                             Profile* profile,
-                                             PrefServiceDelegate* delegate);
+                                        Profile* profile,
+                                        bool async);
 
   // Creates an incognito copy of the pref service that shares most pref stores
   // but uses a fresh non-persistent overlay for the user pref store and an
   // individual extension pref store (to cache the effective extension prefs for
   // incognito windows).
   PrefService* CreateIncognitoPrefService(PrefStore* incognito_extension_prefs);
 
   virtual ~PrefService();
 
   // Reloads the data from file. This should only be called when the importer
@@ skipping 98 matching lines @@
   // PrefStore pointers. This constructor is what CreatePrefService() ends up
   // calling. It's also used for unit tests.
   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);
+              bool async);
 
   // 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 {
@@ skipping 37 matching lines @@
   // RegisterPreference must not be called twice for the same path.
   // This method takes ownership of |default_value|.
   void RegisterPreference(const char* path, Value* default_value);
 
   // Sets the value for this pref path in the user pref store and informs the
   // PrefNotifier of the change.
   void SetUserPrefValue(const char* path, Value* new_value);
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
-  void InitFromStorage();
+  void InitFromStorage(bool async);
 
   // Used to set the value of dictionary or list values in the user pref store.
   // This will create a dictionary or list if one does not exist in the user
   // pref store. This method returns NULL only if you're requesting an
   // unregistered pref or a non-dict/non-list pref.
   // |type| may only be Values::TYPE_DICTIONARY or Values::TYPE_LIST and
   // |path| must point to a registered preference of type |type|.
   // Ownership of the returned value remains at the user pref store.
   Value* GetMutableUserPref(const char* path, Value::ValueType type);
 
   // The PrefValueStore provides prioritized preference values. It is created
   // and owned by this PrefService. Subclasses may access it for unit testing.
   scoped_ptr<PrefValueStore> pref_value_store_;
 
   // Pref Stores and profile that we passed to the PrefValueStore.
   scoped_refptr<PersistentPrefStore> user_pref_store_;
   scoped_refptr<DefaultPrefStore> default_store_;
 
   // Local cache of registered Preference objects. The default_store_
   // is authoritative with respect to what the types and default values
   // of registered preferences are.
   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_