detect preferences errors

chrome/browser/pref_service.h

 // Copyright (c) 2006-2008 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.
 // This service has two preference stores, one for "persistent" preferences,
 // which get serialized for use in the next session, and one for "transient"
 // preferences, which are in effect for only the current session
 // (this usually encodes things like command-line switches).
 //
@@ skipping 166 matching lines @@
   typedef std::set<Preference*, PreferencePathComparator> PreferenceSet;
   const PreferenceSet& preference_set() const { return prefs_; }
 
   // A helper method to quickly look up a preference.  Returns NULL if the
   // preference is not registered.
   const Preference* FindPreference(const wchar_t* pref_name) const;
 
   // ImportantFileWriter::DataSerializer
   virtual bool SerializeData(std::string* output);
 
+  bool read_only() const { return read_only_; }
+
  private:
+  // Unique integer code for each type of error so we can report them
+  // distinctly in a histogram.
+  // NOTE: Don't change the order here as it will change the server's meaning
+  // of the histogram.
+  enum PrefReadError {
+    PREF_READ_ERROR_NONE = 0,
+    PREF_READ_ERROR_JSON_PARSE,
+    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,
+  };
+
   // Add a preference to the PreferenceMap.  If the pref already exists, return
   // false.  This method takes ownership of |pref|.
   void RegisterPreference(Preference* pref);
 
   // Returns a copy of the current pref value.  The caller is responsible for
   // deleting the returned object.
   Value* GetPrefCopy(const wchar_t* pref_name);
 
   // For the given pref_name, fire any observer of the pref.
   void FireObservers(const wchar_t* pref_name);
 
   // For the given pref_name, fire any observer of the pref only if |old_value|
   // is different from the current value.
   void FireObserversIfChanged(const wchar_t* pref_name,
                               const Value* old_value);
 
+  // Load from disk.  Returns a non-zero error code on failure.
+  PrefReadError LoadPersistentPrefs();
+
+  // Load preferences from disk, attempting to diagnose and handle errors.
+  // This should only be called from the constructor.
+  void InitFromDisk();
+
   scoped_ptr<DictionaryValue> persistent_;
 
   // Helper for safe writing pref data.
   ImportantFileWriter writer_;
 
   // A set of all the registered Preference objects.
   PreferenceSet prefs_;
 
   // A map from pref names to a list of observers.  Observers get fired in the
   // order they are added.
   typedef ObserverList<NotificationObserver> NotificationObserverList;
   typedef base::hash_map<std::wstring, NotificationObserverList*>
       PrefObserverMap;
   PrefObserverMap pref_observers_;
 
+  // Whether the service 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.
+  bool read_only_;
+
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREF_SERVICE_H_