Profile shouldn't own PersonalDataManager

chrome/browser/sync/glue/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/sync/glue/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"
+#include "chrome/browser/autofill/form_group.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/api/sync_error.h"
-#include "chrome/browser/sync/glue/do_optimistic_refresh_task.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/web_database.h"
+#include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/guid.h"
+#include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 
 namespace {
 
 // Helper to compare the local value and cloud value of a field, merge into
 // the local value if they differ, and return whether the merge happened.
 bool MergeField(FormGroup* form_group,
                 AutofillFieldType field_type,
                 const std::string& specifics_field) {
   if (UTF16ToUTF8(form_group->GetInfo(field_type)) == specifics_field)
     return false;
   form_group->SetInfo(field_type, UTF8ToUTF16(specifics_field));
   return true;
 }
 
+// Helper to notify listeners of batch change to Autofill data.  |profile| may
+// be NULL for testing.
+void NotifyOfMultipleAutofillChanges(Profile* profile) {
+  if (!profile)
+    return;
+
+  WebDataService* web_data_service =
+    profile->GetWebDataService(Profile::EXPLICIT_ACCESS);
+  if (web_data_service)
+    web_data_service->NotifyOfMultipleAutofillChanges();
+}
+
 }  // namespace
 
 namespace browser_sync {
 
 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
 
 AutofillProfileSyncableService::AutofillProfileSyncableService(
     WebDatabase* web_database,
-    PersonalDataManager* personal_data,
     Profile* profile)
     : web_database_(web_database),
-      personal_data_(personal_data),
+      profile_(profile),
       sync_processor_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(web_database_);
-  DCHECK(personal_data_);
   DCHECK(profile);
   notification_registrar_.Add(this,
       chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED,
       Source<WebDataService>(
-          profile->GetWebDataService(Profile::EXPLICIT_ACCESS)));
+          profile_->GetWebDataService(Profile::EXPLICIT_ACCESS)));
 }
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 AutofillProfileSyncableService::AutofillProfileSyncableService()
     : web_database_(NULL),
-      personal_data_(NULL),
+      profile_(NULL),
       sync_processor_(NULL) {
 }
 
 SyncError AutofillProfileSyncableService::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
     SyncChangeProcessor* sync_processor) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_processor_ == NULL);
   VLOG(1) << "Associating Autofill: MergeDataAndStartSyncing";
@@ skipping 40 matching lines @@
   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);
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      new DoOptimisticRefreshForAutofill(personal_data_));
+  NotifyOfMultipleAutofillChanges(profile_);
 
   return error;
 }
 
 void AutofillProfileSyncableService::StopSyncing(syncable::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_processor_ != NULL);
   DCHECK_EQ(type, syncable::AUTOFILL_PROFILE);
 
   sync_processor_ = NULL;
@@ skipping 47 matching lines @@
         NOTREACHED() << "Unexpected sync change state.";
         return SyncError(FROM_HERE, "ProcessSyncChanges failed on ChangeType " +
                          SyncChange::ChangeTypeToString(i->change_type()),
                          syncable::AUTOFILL_PROFILE);
     }
   }
 
   if (!SaveChangesToWebData(bundle))
     return SyncError(FROM_HERE, "Failed to update webdata.", model_type());
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      new DoOptimisticRefreshForAutofill(personal_data_));
+  NotifyOfMultipleAutofillChanges(profile_);
+
   return SyncError();
 }
 
 void AutofillProfileSyncableService::Observe(int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_AUTOFILL_PROFILE_CHANGED);
   // 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
@@ skipping 204 matching lines @@
   WriteAutofillProfile(profile, &specifics);
   return SyncData::CreateLocalData(profile.guid(), profile.guid(), specifics);
 }
 
 AutofillProfileSyncableService::DataBundle::DataBundle() {}
 
 AutofillProfileSyncableService::DataBundle::~DataBundle() {
 }
 
 }  // namespace browser_sync