Clear a preference when sync tries to delete a preference

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"
@@ skipping 453 matching lines @@
                             syncer::SyncError::DATATYPE_ERROR,
                             "Models not yet associated.",
                             PREFERENCES);
     return error;
   }
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
   syncer::SyncChangeList::const_iterator iter;
   for (iter = change_list.begin(); iter != change_list.end(); ++iter) {
     DCHECK_EQ(type_, iter->sync_data().GetDataType());
 
-    std::string name;
     const sync_pb::PreferenceSpecifics& pref_specifics =
         GetSpecifics(iter->sync_data());
 
-    scoped_ptr<base::Value> value(ReadPreferenceSpecifics(pref_specifics,
-                                                          &name));
-
-    if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
-      // We never delete preferences.
-      NOTREACHED() << "Attempted to process sync delete change for " << name
-                   << ". Skipping.";
-      continue;
-    }
-
-    // Skip values we can't deserialize.
-    // TODO(zea): consider taking some further action such as erasing the bad
-    // data.
-    if (!value.get())
-      continue;
-
+    std::string name = pref_specifics.name();
     // It is possible that we may receive a change to a preference we do not
     // want to sync. For example if the user is syncing a Mac client and a
     // Windows client, the Windows client does not support
     // kConfirmToQuitEnabled. Ignore updates from these preferences.
     const char* pref_name = name.c_str();
     std::string new_name;
     // We migrated this preference name, so do as if the name had not changed.
     if (IsOldMigratedPreference(pref_name)) {
       new_name = GetNewMigratedPreferenceName(pref_name);
       pref_name = new_name.c_str();
     }
 
     if (!IsPrefRegistered(pref_name))
       continue;
 
-    const PrefService::Preference* pref =
-        pref_service_->FindPreference(pref_name);
-    DCHECK(pref);
+    if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
+      pref_service_->ClearPref(pref_name);
+      continue;
+    }
+
+    scoped_ptr<base::Value> value(ReadPreferenceSpecifics(pref_specifics));
+    if (!value.get()) {
+      // Skip values we can't deserialize.
+      // TODO(zea): consider taking some further action such as erasing the bad
+      // data.
+      continue;
+    }
 
     // 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();
 }
 
 base::Value* PrefModelAssociator::ReadPreferenceSpecifics(
-    const sync_pb::PreferenceSpecifics& preference,
-    std::string* name) {
+    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();
     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];
@@ skipping 105 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));
 }