Add migration code to change existing domain scoped content settings to be origin scoped

components/syncable_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 "components/syncable_prefs/pref_model_associator.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/callback.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/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/prefs/pref_service.h"
 #include "components/syncable_prefs/pref_model_associator_client.h"
@@ skipping 27 matching lines @@
     DCHECK(!specifics->has_preference());
     return specifics->mutable_priority_preference()->mutable_preference();
   } else {
     DCHECK(!specifics->has_priority_preference());
     return specifics->mutable_preference();
   }
 }
 
 }  // namespace
 
+base::Closure syncable_prefs::PrefModelAssociator::migrate_call_back_;
+
 PrefModelAssociator::PrefModelAssociator(
     const PrefModelAssociatorClient* client,
     syncer::ModelType type)
     : models_associated_(false),
       processing_syncer_changes_(false),
       pref_service_(NULL),
       type_(type),
       client_(client) {
   DCHECK(CalledOnValidThread());
   DCHECK(type_ == PREFERENCES || type_ == PRIORITY_PREFERENCES);
@@ skipping 83 matching lines @@
                            sync_data));
     synced_preferences_.insert(pref_name);
   }
 
   // Else this pref does not have a sync value but also does not have a user
   // controlled value (either it's a default value or it's policy controlled,
   // either way it's not interesting). We can ignore it. Once it gets changed,
   // we'll send the new user controlled value to the syncer.
 }
 
+// static
+void PrefModelAssociator::SetMergeDataFinishedCallback(
+    const base::Closure& callback) {
+  migrate_call_back_ = callback;
+}
+
+// static
+void PrefModelAssociator::ResetMergeDataFinishedCallback() {
+  migrate_call_back_.Reset();
+}
+
 syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
     std::unique_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK_EQ(type_, type);
   DCHECK(CalledOnValidThread());
   DCHECK(pref_service_);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
@@ skipping 29 matching lines @@
     InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes);
   }
 
   // Go through and build sync data for any remaining preferences.
   for (std::set<std::string>::iterator pref_name_iter =
           remaining_preferences.begin();
        pref_name_iter != remaining_preferences.end();
        ++pref_name_iter) {
     InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
-
+  if (!migrate_call_back_.is_null()) {
+    migrate_call_back_.Run();
+  }
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
   models_associated_ = true;
   pref_service_->OnIsSyncingChanged();
   return merge_result;
 }
@@ skipping 311 matching lines @@
   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));
 }
 
 }  // namespace syncable_prefs