Profile shouldn't own PersonalDataManager

chrome/browser/sync/glue/autofill_model_associator.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_model_associator.h"
 
 #include <functional>
 #include <vector>
 
 #include "base/location.h"
+#include "base/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/autofill_change_processor.h"
-#include "chrome/browser/sync/glue/do_optimistic_refresh_task.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/webdata/autofill_table.h"
 #include "chrome/browser/webdata/web_database.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"
+#include "content/common/notification_source.h"

[Ilya Sherman, 2011/09/23 03:56:34]

nit: I'm not seeing why these header additions are needed.

[dhollowa, 2011/09/23 16:30:03]

Vestigial.  Removed.

 #include "net/base/escape.h"
 
 using base::TimeTicks;
 
 namespace browser_sync {
 
 const char kAutofillTag[] = "google_chrome_autofill";
 const char kAutofillEntryNamespaceTag[] = "autofill_entry|";
 
 struct AutofillModelAssociator::DataBundle {
   std::set<AutofillKey> current_entries;
   std::vector<AutofillEntry> new_entries;
   std::set<string16> current_profiles;
   std::vector<AutofillProfile*> updated_profiles;
   std::vector<AutofillProfile*> new_profiles;  // We own these pointers.
   ~DataBundle() { STLDeleteElements(&new_profiles); }
 };
 
 AutofillModelAssociator::AutofillModelAssociator(
     ProfileSyncService* sync_service,
     WebDatabase* web_database,
-    PersonalDataManager* personal_data)
+    Profile* profile)
     : sync_service_(sync_service),
       web_database_(web_database),
-      personal_data_(personal_data),
+      profile_(profile),
       autofill_node_id_(sync_api::kInvalidId),
       abort_association_pending_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(sync_service_);
   DCHECK(web_database_);
-  DCHECK(personal_data_);
+  DCHECK(profile_);
 }
 
 AutofillModelAssociator::~AutofillModelAssociator() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
 bool AutofillModelAssociator::TraverseAndAssociateChromeAutofillEntries(
     sync_api::WriteTransaction* write_trans,
     const sync_api::ReadNode& autofill_root,
     const std::vector<AutofillEntry>& all_entries_from_db,
@@ skipping 120 matching lines @@
   // Since we're on the DB thread, we don't have to worry about updating
   // the autofill database after closing the write transaction, since
   // this is the only thread that writes to the database.  We also don't have
   // to worry about the sync model getting out of sync, because changes are
   // propagated to the ChangeProcessor on this thread.
   if (!SaveChangesToWebData(bundle)) {
     error->Reset(FROM_HERE, "Failed to update webdata.", model_type());
     return false;
   }
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      new DoOptimisticRefreshForAutofill(personal_data_));
+  WebDataService* web_data_service =
+    profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
+  if (web_data_service)
+    web_data_service->NotifyOfMultipleAutofillChanges();
+
   return true;
 }
 
 bool AutofillModelAssociator::SaveChangesToWebData(const DataBundle& bundle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   if (IsAbortPending())
     return false;
 
   if (bundle.new_entries.size() &&
@@ skipping 301 matching lines @@
 bool AutofillModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   syncable::ModelTypeSet encrypted_types;
   encrypted_types = sync_api::GetEncryptedTypes(&trans);
   return encrypted_types.count(syncable::AUTOFILL) == 0 ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync