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

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 1240 matching lines @@
   } else {
     LOG(WARNING) << "CheckForUpdatesSoon() called with auto-update turned off";
   }
 }
 
 namespace {
   bool IsSyncableNone(const Extension& extension) { return false; }
 }  // namespace
 
 ExtensionService::SyncBundle::SyncBundle()
-  : filter(IsSyncableNone),
-    sync_processor(NULL) {
+  : filter(IsSyncableNone) {
 }
 
 ExtensionService::SyncBundle::~SyncBundle() {
 }
 
+void ExtensionService::SyncBundle::Reset() {
+  filter = IsSyncableNone;
+  synced_extensions.clear();
+  pending_sync_data.clear();
+  sync_processor.reset();
+}
+
 bool ExtensionService::SyncBundle::HasExtensionId(const std::string& id) const {
   return synced_extensions.find(id) != synced_extensions.end();
 }
 
 bool ExtensionService::SyncBundle::HasPendingExtensionId(const std::string& id)
     const {
   return pending_sync_data.find(id) != pending_sync_data.end();
 }
 
 void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
@@ skipping 64 matching lines @@
 ExtensionService::SyncBundle* ExtensionService::GetSyncBundleForModelType(
     syncable::ModelType type) {
   GET_SYNC_BUNDLE_FOR_MODEL_TYPE_BODY();
 }
 
 #undef GET_SYNC_BUNDLE_FOR_MODEL_TYPE_BODY
 
 SyncError ExtensionService::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
-    SyncChangeProcessor* sync_processor) {
-  CHECK(sync_processor);
-
+    scoped_ptr<SyncChangeProcessor> sync_processor) {
   SyncBundle* bundle = NULL;
 
   switch (type) {
     case syncable::EXTENSIONS:
       bundle = &extension_sync_bundle_;
       bundle->filter = IsSyncableExtension;
       break;
 
     case syncable::APPS:
       bundle = &app_sync_bundle_;
       bundle->filter = IsSyncableApp;
       break;
 
     default:
       LOG(FATAL) << "Got " << type << " ModelType";
   }
-
-  bundle->sync_processor = sync_processor;
+  DCHECK(!bundle->sync_processor.get());
+  DCHECK(sync_processor.get());
+  bundle->sync_processor = sync_processor.Pass();
 
   // Process extensions from sync.
   for (SyncDataList::const_iterator i = initial_sync_data.begin();
        i != initial_sync_data.end();
        ++i) {
     ExtensionSyncData extension_sync_data = ExtensionSyncData(*i);
     bundle->synced_extensions.insert(extension_sync_data.id());
     ProcessExtensionSyncData(extension_sync_data, *bundle);
   }
 
@@ skipping 15 matching lines @@
   bundle->sync_processor->ProcessSyncChanges(FROM_HERE, sync_change_list);
 
   extension_prefs_->extension_sorting()->FixNTPOrdinalCollisions();
 
   return SyncError();
 }
 
 void ExtensionService::StopSyncing(syncable::ModelType type) {
   SyncBundle* bundle = GetSyncBundleForModelType(type);
   CHECK(bundle);
-  // This is the simplest way to clear out the bundle.
-  *bundle = SyncBundle();
+  bundle->Reset();
 }
 
 SyncDataList ExtensionService::GetAllSyncData(syncable::ModelType type) const {
   const SyncBundle* bundle = GetSyncBundleForModelTypeConst(type);
   CHECK(bundle);
   std::vector<ExtensionSyncData> extension_sync_data = GetSyncDataList(*bundle);
   SyncDataList result(extension_sync_data.size());
   for (int i = 0; i < static_cast<int>(extension_sync_data.size()); ++i) {
     result[i] = extension_sync_data[i].GetSyncData();
   }
@@ skipping 1248 matching lines @@
   return api_resource_controller_;
 }
 
 extensions::RulesRegistryService* ExtensionService::GetRulesRegistryService() {
   if (!rules_registry_service_.get()) {
     rules_registry_service_.reset(
         new extensions::RulesRegistryService(profile_));
   }
   return rules_registry_service_.get();
 }