Pref service: Add a ScopedDictionaryPrefUpdate to track value changes.

components/prefs/pref_service.h

 // Copyright (c) 2012 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.
 
 // Chromium settings and storage represent user-selected preferences and
 // information and MUST not be extracted, overwritten or modified except
 // through Chromium defined APIs.
 
@@ skipping 21 matching lines @@
 class PrefNotifierImpl;
 class PrefObserver;
 class PrefRegistry;
 class PrefValueStore;
 class PrefStore;
 
 namespace base {
 class FilePath;
 }
 
+namespace prefs {
+class ScopedDictionaryPrefUpdate;
+}
+
 namespace subtle {
 class PrefMemberBase;
 class ScopedUserPrefUpdateBase;
 }
 
 // Base class for PrefServices. You can use the base class to read and
 // interact with preferences, but not to register new preferences; for
 // that see e.g. PrefRegistrySimple.
 //
 // Settings and storage accessed through this class represent
@@ skipping 268 matching lines @@
  private:
   // Hash map expected to be fastest here since it minimises expensive
   // string comparisons. Order is unimportant, and deletions are rare.
   // Confirmed on Android where this speeded Chrome startup by roughly 50ms
   // vs. std::map, and by roughly 180ms vs. std::set of Preference pointers.
   typedef base::hash_map<std::string, Preference> PreferenceMap;
 
   // Give access to ReportUserPrefChanged() and GetMutableUserPref().
   friend class subtle::ScopedUserPrefUpdateBase;
   friend class PrefServiceTest_WriteablePrefStoreFlags_Test;
+  friend class prefs::ScopedDictionaryPrefUpdate;
 
   // Registration of pref change observers must be done using the
   // PrefChangeRegistrar, which is declared as a friend here to grant it
   // access to the otherwise protected members Add/RemovePrefObserver.
   // PrefMember registers for preferences changes notification directly to
   // avoid the storage overhead of the registrar, so its base class must be
   // declared as a friend, too.
   friend class PrefChangeRegistrar;
   friend class subtle::PrefMemberBase;
 
   // These are protected so they can only be accessed by the friend
   // classes listed above.
   //
   // If the pref at the given path changes, we call the observer's
   // OnPreferenceChanged method. Note that observers should not call
   // these methods directly but rather use a PrefChangeRegistrar to
   // make sure the observer gets cleaned up properly.
   //
   // Virtual for testing.
   virtual void AddPrefObserver(const std::string& path, PrefObserver* obs);
   virtual void RemovePrefObserver(const std::string& path, PrefObserver* obs);
 
   // Sends notification of a changed preference. This needs to be called by
   // a ScopedUserPrefUpdate if a DictionaryValue or ListValue is changed.
   void ReportUserPrefChanged(const std::string& key);
+  void ReportUserPrefChanged(
+      const std::string& key,
+      std::set<std::vector<std::string>> path_components);
 
   // Sets the value for this pref path in the user pref store and informs the
   // PrefNotifier of the change.
   void SetUserPrefValue(const std::string& path,
                         std::unique_ptr<base::Value> new_value);
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
   void InitFromStorage(bool async);
 
@@ skipping 16 matching lines @@
 
   // Local cache of registered Preference objects. The pref_registry_
   // is authoritative with respect to what the types and default values
   // of registered preferences are.
   mutable PreferenceMap prefs_map_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // COMPONENTS_PREFS_PREF_SERVICE_H_