[Sync] Have SyncableService's take ownership of their SyncChangeProcessor.

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/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/api/sync_change.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 
 using syncable::PREFERENCES;
 
 PrefModelAssociator::PrefModelAssociator()
     : models_associated_(false),
       processing_syncer_changes_(false),
-      pref_service_(NULL),
-      sync_processor_(NULL) {
+      pref_service_(NULL) {
   DCHECK(CalledOnValidThread());
 }
 
 PrefModelAssociator::~PrefModelAssociator() {
   DCHECK(CalledOnValidThread());
-  sync_processor_ = NULL;
   pref_service_ = NULL;
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const SyncData& sync_pref,
     const std::string& pref_name,
     SyncChangeList* sync_changes) {
   const PrefService::Preference* pref =
       pref_service_->FindPreference(pref_name.c_str());
   DCHECK(pref);
@@ skipping 59 matching lines @@
 
   // Make sure we add it to our list of synced preferences so we know what
   // the server is aware of.
   synced_preferences_.insert(pref_name);
   return;
 }
 
 SyncError PrefModelAssociator::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
-    SyncChangeProcessor* sync_processor) {
+    scoped_ptr<SyncChangeProcessor> sync_processor) {
   DCHECK_EQ(type, PREFERENCES);
   DCHECK(CalledOnValidThread());
   DCHECK(pref_service_);
-  DCHECK(!sync_processor_);
-  sync_processor_ = sync_processor;
+  DCHECK(!sync_processor_.get());
+  DCHECK(sync_processor.get());
+  sync_processor_ = sync_processor.Pass();
 
   SyncChangeList new_changes;
   std::set<std::string> remaining_preferences = registered_preferences_;
 
   // Go through and check for all preferences we care about that sync already
   // knows about.
   for (SyncDataList::const_iterator sync_iter = initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     DCHECK_EQ(PREFERENCES, sync_iter->GetDataType());
@@ skipping 26 matching lines @@
     return error;
   }
 
   models_associated_ = true;
   return SyncError();
 }
 
 void PrefModelAssociator::StopSyncing(syncable::ModelType type) {
   DCHECK_EQ(type, PREFERENCES);
   models_associated_ = false;
-  sync_processor_ = NULL;
+  sync_processor_.reset();
 }
 
 Value* PrefModelAssociator::MergePreference(
     const PrefService::Preference& local_pref,
     const Value& server_value) {
   const std::string& name(local_pref.name());
   if (name == prefs::kURLsToRestoreOnStartup ||
       name == prefs::kDesktopNotificationAllowedOrigins ||
       name == prefs::kDesktopNotificationDeniedOrigins) {
     return MergeListValues(*local_pref.GetValue(), server_value);
@@ skipping 243 matching lines @@
     SyncData sync_data;
     if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
     changes.push_back(SyncChange(SyncChange::ACTION_UPDATE, sync_data));
   }
 
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
-  if (error.IsSet())
-    StopSyncing(PREFERENCES);
 }
 
 void PrefModelAssociator::SetPrefService(PrefService* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }