Add histograms to track synced pref changes.

chrome/browser/prefs/pref_model_associator.cc

 // 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.
 
 #include "chrome/browser/prefs/pref_model_associator.h"
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
+#include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/common/pref_names.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 
@@ skipping 31 matching lines @@
       processing_syncer_changes_(false),
       pref_service_(NULL),
       type_(type) {
   DCHECK(CalledOnValidThread());
   DCHECK(type_ == PREFERENCES || type_ == PRIORITY_PREFERENCES);
 }
 
 PrefModelAssociator::~PrefModelAssociator() {
   DCHECK(CalledOnValidThread());
   pref_service_ = NULL;
+
+  STLDeleteContainerPairSecondPointers(synced_pref_observers_.begin(),
+                                       synced_pref_observers_.end());
+  synced_pref_observers_.clear();
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
     syncer::SyncChangeList* sync_changes) {
   const Value* user_pref_value = pref_service_->GetUserPrefValue(
       pref_name.c_str());
   VLOG(1) << "Associating preference " << pref_name;
 
@@ skipping 314 matching lines @@
 
     const PrefService::Preference* pref =
         pref_service_->FindPreference(pref_name);
     DCHECK(pref);
 
     // This will only modify the user controlled value store, which takes
     // priority over the default value but is ignored if the preference is
     // policy controlled.
     pref_service_->Set(pref_name, *value);
 
+    NotifySyncedPrefObservers(name, true /*from_sync*/);
+
     // Keep track of any newly synced preferences.
     if (iter->change_type() == syncer::SyncChange::ACTION_ADD) {
       synced_preferences_.insert(name);
     }
   }
   return syncer::SyncError();
 }
 
 Value* PrefModelAssociator::ReadPreferenceSpecifics(
     const sync_pb::PreferenceSpecifics& preference,
     std::string* name) {
   base::JSONReader reader;
   scoped_ptr<Value> value(reader.ReadToValue(preference.value()));
   if (!value.get()) {
     std::string err = "Failed to deserialize preference value: " +
         reader.GetErrorMessage();
     LOG(ERROR) << err;
     return NULL;
   }
   *name = preference.name();
   return value.release();
 }
 
 bool PrefModelAssociator::IsPrefSynced(const std::string& name) const {
   return synced_preferences_.find(name) != synced_preferences_.end();
 }
 
+void PrefModelAssociator::AddSyncedPrefObserver(const std::string& name,
+    SyncedPrefObserver* observer) {
+  SyncedPrefObserverList* observers = synced_pref_observers_[name];
+  if (observers == NULL) {
+    observers = new SyncedPrefObserverList;
+    synced_pref_observers_[name] = observers;
+  }
+  observers->AddObserver(observer);
+}
+
+void PrefModelAssociator::RemoveSyncedPrefObserver(const std::string& name,
+    SyncedPrefObserver* observer) {
+  SyncedPrefObserverMap::iterator observer_iter =
+      synced_pref_observers_.find(name);
+  if (observer_iter == synced_pref_observers_.end())
+    return;
+  SyncedPrefObserverList* observers = observer_iter->second;
+  observers->RemoveObserver(observer);
+}
+
 std::set<std::string> PrefModelAssociator::registered_preferences() const {
   return registered_preferences_;
 }
 
 void PrefModelAssociator::RegisterPref(const char* name) {
   DCHECK(!models_associated_ && registered_preferences_.count(name) == 0);
   registered_preferences_.insert(name);
 }
 
 bool PrefModelAssociator::IsPrefRegistered(const char* name) {
@@ skipping 21 matching lines @@
   if (!preference->IsUserModifiable()) {
     // If the preference is no longer user modifiable, it must now be controlled
     // by policy, whose values we do not sync. Just return. If the preference
     // stops being controlled by policy, it will revert back to the user value
     // (which we continue to update with sync changes).
     return;
   }
 
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
+  NotifySyncedPrefObservers(name, false /*from_sync*/);
+
   if (synced_preferences_.count(name) == 0) {
     // Not in synced_preferences_ means no synced data. InitPrefAndAssociate(..)
     // will determine if we care about its data (e.g. if it has a default value
     // and hasn't been changed yet we don't) and take care syncing any new data.
     InitPrefAndAssociate(syncer::SyncData(), name, &changes);
   } else {
     // We are already syncing this preference, just update it's sync node.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
     changes.push_back(
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_UPDATE,
                            sync_data));
   }
 
   syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }
+
+void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path,
+                                                    bool from_sync) const {
+  SyncedPrefObserverMap::const_iterator observer_iter =
+      synced_pref_observers_.find(path);
+  if (observer_iter == synced_pref_observers_.end())
+    return;
+  SyncedPrefObserverList* observers = observer_iter->second;
+  FOR_EACH_OBSERVER(SyncedPrefObserver, *observers,
+                    OnSyncedPrefChanged(path, from_sync));
+}