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

chrome/browser/extensions/settings/settings_backend.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/extensions/settings/settings_backend.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 13 matching lines @@
 
 SettingsBackend::SettingsBackend(
     const scoped_refptr<SettingsStorageFactory>& storage_factory,
     const FilePath& base_path,
     const SettingsStorageQuotaEnforcer::Limits& quota,
     const scoped_refptr<SettingsObserverList>& observers)
     : storage_factory_(storage_factory),
       base_path_(base_path),
       quota_(quota),
       observers_(observers),
-      sync_type_(syncable::UNSPECIFIED),
-      sync_processor_(NULL) {
+      sync_type_(syncable::UNSPECIFIED) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SettingsBackend::~SettingsBackend() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SettingsStorage* SettingsBackend::GetStorage(
     const std::string& extension_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 19 matching lines @@
     storage = new FailingSettingsStorage();
   }
 
   linked_ptr<SyncableSettingsStorage> syncable_storage(
       new SyncableSettingsStorage(
           observers_,
           extension_id,
           storage));
   storage_objs_[extension_id] = syncable_storage;
 
-  if (sync_processor_) {
+  if (sync_processor_.get()) {
     SyncError error =
-        syncable_storage->StartSyncing(sync_type_, sync_data, sync_processor_);
+        syncable_storage->StartSyncing(sync_type_,
+                                       sync_data,
+                                       sync_processor_.get());
     if (error.IsSet()) {
       syncable_storage.get()->StopSyncing();
     }
   }
 
   return syncable_storage.get();
 }
 
 void SettingsBackend::DeleteStorage(const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 76 matching lines @@
     }
     AddAllSyncData(*it, maybe_settings.settings(), type, &all_sync_data);
   }
 
   return all_sync_data;
 }
 
 SyncError SettingsBackend::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
-    SyncChangeProcessor* sync_processor) {
+    scoped_ptr<SyncChangeProcessor> sync_processor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(type == syncable::EXTENSION_SETTINGS ||
          type == syncable::APP_SETTINGS);
   DCHECK_EQ(sync_type_, syncable::UNSPECIFIED);
-  DCHECK(!sync_processor_);
+  DCHECK(!sync_processor_.get());
+  DCHECK(sync_processor.get());
 
   sync_type_ = type;
-  sync_processor_ = sync_processor;
+  sync_processor_ = sync_processor.Pass();
 
   // Group the initial sync data by extension id.
   std::map<std::string, linked_ptr<DictionaryValue> > grouped_sync_data;
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
       it != initial_sync_data.end(); ++it) {
     SettingSyncData data(*it);
     linked_ptr<DictionaryValue> sync_data =
         grouped_sync_data[data.extension_id()];
     if (!sync_data.get()) {
       sync_data = linked_ptr<DictionaryValue>(new DictionaryValue());
       grouped_sync_data[data.extension_id()] = sync_data;
     }
     DCHECK(!sync_data->HasKey(data.key())) <<
         "Duplicate settings for " << data.extension_id() << "/" << data.key();
     sync_data->Set(data.key(), data.value().DeepCopy());
   }
 
   // Start syncing all existing storage areas.  Any storage areas created in
   // the future will start being synced as part of the creation process.
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     std::map<std::string, linked_ptr<DictionaryValue> >::iterator
         maybe_sync_data = grouped_sync_data.find(it->first);
     SyncError error;
     if (maybe_sync_data != grouped_sync_data.end()) {
       error = it->second->StartSyncing(
-          type, *maybe_sync_data->second, sync_processor);
+          type, *maybe_sync_data->second, sync_processor_.get());
       grouped_sync_data.erase(it->first);
     } else {
       DictionaryValue empty;
-      error = it->second->StartSyncing(type, empty, sync_processor);
+      error = it->second->StartSyncing(type, empty, sync_processor_.get());
     }
     if (error.IsSet()) {
       it->second->StopSyncing();
     }
   }
 
   // Eagerly create and init the rest of the storage areas that have sync data.
   // Under normal circumstances (i.e. not first-time sync) this will be all of
   // them.
   for (std::map<std::string, linked_ptr<DictionaryValue> >::iterator it =
       grouped_sync_data.begin(); it != grouped_sync_data.end(); ++it) {
     GetOrCreateStorageWithSyncData(it->first, *it->second);
   }
 
   return SyncError();
 }
 
 SyncError SettingsBackend::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& sync_changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(sync_processor_);
+  DCHECK(sync_processor_.get());
 
   // Group changes by extension, to pass all changes in a single method call.
   std::map<std::string, SettingSyncDataList> grouped_sync_data;
   for (SyncChangeList::const_iterator it = sync_changes.begin();
       it != sync_changes.end(); ++it) {
     SettingSyncData data(*it);
     grouped_sync_data[data.extension_id()].push_back(data);
   }
 
   // Create any storage areas that don't exist yet but have sync data.
   DictionaryValue empty;
   for (std::map<std::string, SettingSyncDataList>::iterator
       it = grouped_sync_data.begin(); it != grouped_sync_data.end(); ++it) {
     SyncableSettingsStorage* storage =
         GetOrCreateStorageWithSyncData(it->first, empty);
     SyncError error = storage->ProcessSyncChanges(it->second);
     if (error.IsSet())
       storage->StopSyncing();
   }
 
   return SyncError();
 }
 
 void SettingsBackend::StopSyncing(syncable::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(type == syncable::EXTENSION_SETTINGS ||
          type == syncable::APP_SETTINGS);
   DCHECK_EQ(type, sync_type_);
-  DCHECK(sync_processor_);
-
-  sync_type_ = syncable::UNSPECIFIED;
-  sync_processor_ = NULL;
 
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     // Some storage areas may have already stopped syncing if they had areas
     // and syncing was disabled, but StopSyncing is safe to call multiple times.
     it->second->StopSyncing();
   }
+
+  sync_type_ = syncable::UNSPECIFIED;
+  sync_processor_.reset();
 }
 
 }  // namespace extensions