[Sync] Refactor non-frontend DTC to handle new API properly.

chrome/browser/webdata/autofill_profile_syncable_service.cc

 // Copyright (c) 2011 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/webdata/autofill_profile_syncable_service.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
@@ skipping 22 matching lines @@
 }
 
 }  // namespace
 
 namespace browser_sync {
 
 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
 
 AutofillProfileSyncableService::AutofillProfileSyncableService(
     WebDataService* web_data_service)
-    : web_data_service_(web_data_service),
-      sync_processor_(NULL) {
+    : web_data_service_(web_data_service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(web_data_service_);
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
                               Source<WebDataService>(web_data_service_));
 }
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 AutofillProfileSyncableService::AutofillProfileSyncableService()
-    : web_data_service_(NULL),
-      sync_processor_(NULL) {
+    : web_data_service_(NULL) {
 }
 
 SyncError AutofillProfileSyncableService::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
     SyncChangeProcessor* sync_processor) {
   DCHECK(CalledOnValidThread());
-  DCHECK(sync_processor_ == NULL);
+  DCHECK(!sync_processor_.get());
   VLOG(1) << "Associating Autofill: MergeDataAndStartSyncing";
 
   if (!LoadAutofillData(&profiles_.get())) {
     return SyncError(
         FROM_HERE, "Could not get the autofill data from WebDatabase.",
         model_type());
   }
 
   if (VLOG_IS_ON(2)) {
     VLOG(2) << "[AUTOFILL MIGRATION]"
             << "Printing profiles from web db";
 
     for (ScopedVector<AutofillProfile>::const_iterator ix =
         profiles_.begin(); ix != profiles_.end(); ++ix) {
       AutofillProfile* p = *ix;
       VLOG(2) << "[AUTOFILL MIGRATION]  "
               << p->GetInfo(NAME_FIRST)
               << p->GetInfo(NAME_LAST)
               << p->guid();
     }
   }
 
-  sync_processor_ = sync_processor;
+  sync_processor_.reset(sync_processor);
 
   GUIDToProfileMap remaining_profiles;
   CreateGUIDToProfileMap(profiles_.get(), &remaining_profiles);
 
   DataBundle bundle;
   // Go through and check for all the profiles that sync already knows about.
   for (SyncDataList::const_iterator sync_iter = initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     GUIDToProfileMap::iterator it =
         CreateOrUpdateProfile(*sync_iter, &remaining_profiles, &bundle);
     profiles_map_[it->first] = it->second;
     remaining_profiles.erase(it);
   }
 
   if (!SaveChangesToWebData(bundle))
     return SyncError(FROM_HERE, "Failed to update webdata.", model_type());
 
   SyncChangeList new_changes;
   for (GUIDToProfileMap::iterator i = remaining_profiles.begin();
        i != remaining_profiles.end(); ++i) {
     new_changes.push_back(
         SyncChange(SyncChange::ACTION_ADD, CreateData(*(i->second))));
     profiles_map_[i->first] = i->second;
   }
 
-  SyncError error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
+  SyncError error;
+  if (!new_changes.empty())
+    error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
 
   return error;
 }
 
 void AutofillProfileSyncableService::StopSyncing(syncable::ModelType type) {
   DCHECK(CalledOnValidThread());
-  DCHECK(sync_processor_ != NULL);
   DCHECK_EQ(type, syncable::AUTOFILL_PROFILE);
 
-  sync_processor_ = NULL;
+  sync_processor_.reset();
   profiles_.reset();
   profiles_map_.clear();
 }
 
 SyncDataList AutofillProfileSyncableService::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK(CalledOnValidThread());
-  DCHECK(sync_processor_ != NULL);
+  DCHECK(sync_processor_.get());
   DCHECK_EQ(type, syncable::AUTOFILL_PROFILE);
 
   SyncDataList current_data;
 
   for (GUIDToProfileMap::const_iterator i = profiles_map_.begin();
        i != profiles_map_.end(); ++i) {
     current_data.push_back(CreateData(*(i->second)));
   }
   return current_data;
 }
 
 SyncError AutofillProfileSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   DCHECK(CalledOnValidThread());
-  DCHECK(sync_processor_ != NULL);
-  if (sync_processor_ == NULL) {
+  if (!sync_processor_.get()) {
     SyncError error(FROM_HERE, "Models not yet associated.",
                     syncable::AUTOFILL_PROFILE);
     return error;
   }
 
   DataBundle bundle;
 
   for (SyncChangeList::const_iterator i = change_list.begin();
        i != change_list.end(); ++i) {
     DCHECK(i->IsValid());
@@ skipping 26 matching lines @@
 
 void AutofillProfileSyncableService::Observe(int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED);
   DCHECK_EQ(web_data_service_, Source<WebDataService>(source).ptr());
   // Check if sync is on. If we receive notification prior to the sync being set
   // up we are going to process all when MergeData..() is called. If we receive
   // notification after the sync exited, it will be sinced next time Chrome
   // starts.
-  if (!sync_processor_)
+  if (!sync_processor_.get())
     return;
 
   AutofillProfileChange* change = Details<AutofillProfileChange>(details).ptr();
   ActOnChange(*change);
 }
 
 bool AutofillProfileSyncableService::LoadAutofillData(
     std::vector<AutofillProfile*>* profiles) {
   return GetAutofillTable()->GetAutofillProfiles(profiles);
 }
@@ skipping 134 matching lines @@
     bundle->profiles_to_add.push_back(new_profile);
   }
   return it;
 }
 
 void AutofillProfileSyncableService::ActOnChange(
      const AutofillProfileChange& change) {
   DCHECK((change.type() == AutofillProfileChange::REMOVE &&
           !change.profile()) ||
          (change.type() != AutofillProfileChange::REMOVE && change.profile()));
-  DCHECK(sync_processor_);
+  DCHECK(sync_processor_.get());
   SyncChangeList new_changes;
   DataBundle bundle;
   switch (change.type()) {
     case AutofillProfileChange::ADD:
       new_changes.push_back(
           SyncChange(SyncChange::ACTION_ADD, CreateData(*(change.profile()))));
       DCHECK(profiles_map_.find(change.profile()->guid()) ==
              profiles_map_.end());
       profiles_.push_back(new AutofillProfile(*(change.profile())));
       profiles_map_[change.profile()->guid()] = profiles_.get().back();
@@ skipping 37 matching lines @@
 AutofillTable* AutofillProfileSyncableService::GetAutofillTable() const {
   return web_data_service_->GetDatabase()->GetAutofillTable();
 }
 
 AutofillProfileSyncableService::DataBundle::DataBundle() {}
 
 AutofillProfileSyncableService::DataBundle::~DataBundle() {
 }
 
 }  // namespace browser_sync