Remove dependency of PrefSyncableService on Profile.

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/prefs/pref_model_associator_client.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
-#include "chrome/common/pref_names.h"
-#include "components/content_settings/core/browser/website_settings_info.h"
-#include "components/content_settings/core/browser/website_settings_registry.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"
 
 using syncer::PREFERENCES;
 using syncer::PRIORITY_PREFERENCES;
 
 namespace {
 
@@ skipping 18 matching lines @@
     return specifics->mutable_preference();
   }
 }
 
 }  // namespace
 
 PrefModelAssociator::PrefModelAssociator(syncer::ModelType type)
     : models_associated_(false),
       processing_syncer_changes_(false),
       pref_service_(NULL),
-      type_(type) {
+      type_(type),
+      pref_model_associator_client_(NULL) {
   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 base::Value* user_pref_value = pref_service_->GetUserPrefValue(
-      pref_name.c_str());
+  const base::Value* user_pref_value =
+      pref_service_->GetUserPrefValue(pref_name.c_str());
   VLOG(1) << "Associating preference " << pref_name;
 
   if (sync_pref.IsValid()) {
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref);
     DCHECK(pref_name == preference.name());
     base::JSONReader reader;
     scoped_ptr<base::Value> sync_value(reader.ReadToValue(preference.value()));
     if (!sync_value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
                  << reader.GetErrorMessage();
       return;
     }
 
     if (user_pref_value) {
       DVLOG(1) << "Found user pref value for " << pref_name;
       // We have both server and local values. Merge them.
       scoped_ptr<base::Value> new_value(
-          MergePreference(pref_name, *user_pref_value, *sync_value));
+          MergePreference(pref_name, *user_pref_value, *sync_value,
+                          pref_model_associator_client_));
 
       // Update the local preference based on what we got from the
       // sync server. Note: this only updates the user value store, which is
       // ignored if the preference is policy controlled.
       if (new_value->IsType(base::Value::TYPE_NULL)) {
         LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
         pref_service_->ClearPref(pref_name.c_str());
       } else if (!new_value->IsType(user_pref_value->GetType())) {
         LOG(WARNING) << "Synced value for " << preference.name()
                      << " is of type " << new_value->GetType()
@@ skipping 104 matching lines @@
 }
 
 void PrefModelAssociator::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(type_, type);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
   pref_service_->OnIsSyncingChanged();
 }
 
+// static
 scoped_ptr<base::Value> PrefModelAssociator::MergePreference(
     const std::string& name,
     const base::Value& local_value,
-    const base::Value& server_value) {
+    const base::Value& server_value,
+    PrefModelAssociatorClient* pref_model_associator_client) {

[gab, 2015/09/10 14:15:09]

Can we make this a member method and have it use |pref_model_associator_client_|
directly? Looks like the only callers are this class and its unittest.

   // This function special cases preferences individually, so don't attempt
   // to merge for all migrated values.
-  if (name == prefs::kURLsToRestoreOnStartup)
-    return make_scoped_ptr(MergeListValues(local_value, server_value));
-
-  content_settings::WebsiteSettingsRegistry* registry =
-      content_settings::WebsiteSettingsRegistry::GetInstance();
-  for (const content_settings::WebsiteSettingsInfo* info : *registry) {
-    if (info->pref_name() == name)
-      return make_scoped_ptr(MergeDictionaryValues(local_value, server_value));
+  PrefModelAssociatorPreferenceType pref_type;
+  if (pref_model_associator_client &&
+      pref_model_associator_client->IsPreferenceMerged(name, &pref_type)) {
+    switch (pref_type) {
+      case PREF_MODEL_PREFERENCE_TYPE_LIST:
+        return make_scoped_ptr(MergeListValues(local_value, server_value));
+      case PREF_MODEL_PREFERENCE_TYPE_DICT:
+        return make_scoped_ptr(
+            MergeDictionaryValues(local_value, server_value));
+    }
   }
 
   // If this is not a specially handled preference, server wins.
   return make_scoped_ptr(server_value.DeepCopy());
 }
 
 bool PrefModelAssociator::CreatePrefSyncData(
     const std::string& name,
     const base::Value& value,
     syncer::SyncData* sync_data) const {
@@ skipping 78 matching lines @@
     }
   }
   return result;
 }
 
 // Note: This will build a model of all preferences registered as syncable
 // with user controlled data. We do not track any information for preferences
 // not registered locally as syncable and do not inform the syncer of
 // non-user controlled preferences.
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
-    syncer::ModelType type)
-    const {
+    syncer::ModelType type) const {
   DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
        iter != synced_preferences_.end();
        ++iter) {
     std::string name = *iter;
     const PrefService::Preference* pref =
-      pref_service_->FindPreference(name.c_str());
+        pref_service_->FindPreference(name.c_str());
     DCHECK(pref);
     if (!pref->IsUserControlled() || pref->IsDefaultValue())
       continue;  // This is not data we care about.
     // TODO(zea): plumb a way to read the user controlled value.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data))
       continue;
     current_data.push_back(sync_data);
   }
   return current_data;
@@ skipping 52 matching lines @@
     }
   }
   return syncer::SyncError();
 }
 
 base::Value* PrefModelAssociator::ReadPreferenceSpecifics(
     const sync_pb::PreferenceSpecifics& preference) {
   base::JSONReader reader;
   scoped_ptr<base::Value> value(reader.ReadToValue(preference.value()));
   if (!value.get()) {
-    std::string err = "Failed to deserialize preference value: " +
-        reader.GetErrorMessage();
+    std::string err =
+        "Failed to deserialize preference value: " + reader.GetErrorMessage();
     LOG(ERROR) << err;
     return NULL;
   }
   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) {
+                                                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,
+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 {
@@ skipping 69 matching lines @@
 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));
 }