Make Autofill SyncableServices use a backend interface for DB work, rather...

Make Autofill SyncableServices use a backend interface for DB work, rather than calling WebDataService directly.

This will (eventually) allow WebDataService to live entirely on the UI Thread, and also ensures that we don't expose any more of the backend functionality than is needed by the SyncableServices.

(depends on: https://codereview.chromium.org/14679005/)

BUG=230920

Review URL: https://chromiumcodereview.appspot.com/14081043

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@201979 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync/glue/autofill_data_type_controller_unittest.cc

@@ -31,6 +31,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using autofill::AutofillWebDataService;
+using autofill::AutofillWebDataBackend;
 
 namespace browser_sync {
 
@@ -41,6 +42,19 @@ using testing::_;
 using testing::NiceMock;
 using testing::Return;
 
+class NoOpAutofillBackend : public AutofillWebDataBackend {
+ public:
+  NoOpAutofillBackend() {}
+  virtual ~NoOpAutofillBackend() {}
+  virtual WebDatabase* GetDatabase() OVERRIDE { return NULL; }
+  virtual void AddObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveExpiredFormElements() OVERRIDE {}
+  virtual void NotifyOfMultipleAutofillChanges() OVERRIDE {}
+};
+
 // Fake WebDataService implementation that stubs out the database loading.
 class FakeWebDataService : public AutofillWebDataService {
  public:
@@ -120,11 +134,13 @@ class FakeWebDataService : public AutofillWebDataService {
   void CreateSyncableService() {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
-    AutocompleteSyncableService::CreateForWebDataService(this);
+    AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
+        this,
+        &autofill_backend_);
   }
 
   bool is_database_loaded_;
-
+  NoOpAutofillBackend autofill_backend_;
   WebDatabaseObserver* observer_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebDataService);

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

@@ -144,6 +144,32 @@ class WebDatabaseFake : public WebDatabase {
   }
 };
 
+class MockAutofillBackend : public autofill::AutofillWebDataBackend {
+ public:
+  MockAutofillBackend(
+      WebDatabase* web_database,
+      const base::Closure& on_changed)
+      : web_database_(web_database),
+        on_changed_(on_changed) {
+  }
+
+  virtual ~MockAutofillBackend() {}
+  virtual WebDatabase* GetDatabase() OVERRIDE { return web_database_; }
+  virtual void AddObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveObserver(
+      autofill::AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE {}
+  virtual void RemoveExpiredFormElements() OVERRIDE {}
+  virtual void NotifyOfMultipleAutofillChanges() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, on_changed_);
+  }
+
+ private:
+  WebDatabase* web_database_;
+  base::Closure on_changed_;
+};
+
 class ProfileSyncServiceAutofillTest;
 
 template<class AutofillProfile>
@@ -206,9 +232,14 @@ class WebDataServiceFake : public AutofillWebDataService {
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
+    const base::Closure& on_changed_callback = base::Bind(
+        &WebDataServiceFake::NotifyAutofillMultipleChangedOnUIThread,
+        AsWeakPtr());
+
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::Bind(&WebDataServiceFake::CreateSyncableService,
-                   base::Unretained(this)));
+                   base::Unretained(this),
+                   on_changed_callback));
     syncable_service_created_or_destroyed_.Wait();
   }
 
@@ -262,11 +293,15 @@ class WebDataServiceFake : public AutofillWebDataService {
  private:
   virtual ~WebDataServiceFake() {}
 
-  void CreateSyncableService() {
+  void CreateSyncableService(const base::Closure& on_changed_callback) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
-    AutocompleteSyncableService::CreateForWebDataService(this);
-    AutofillProfileSyncableService::CreateForWebDataService(this, "en-US");
+    backend_.reset(new MockAutofillBackend(
+        GetDatabase(), on_changed_callback));
+    AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
+        this, backend_.get());
+    AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
+        this, backend_.get(), "en-US");
 
     autocomplete_syncable_service_ =
         AutocompleteSyncableService::FromWebDataService(this);
@@ -281,12 +316,14 @@ class WebDataServiceFake : public AutofillWebDataService {
     AutofillWebDataService::ShutdownOnDBThread();
     autocomplete_syncable_service_ = NULL;
     autofill_profile_syncable_service_ = NULL;
+    backend_.reset();
     syncable_service_created_or_destroyed_.Signal();
   }
 
   WebDatabase* web_database_;
   AutocompleteSyncableService* autocomplete_syncable_service_;
   AutofillProfileSyncableService* autofill_profile_syncable_service_;
+  scoped_ptr<autofill::AutofillWebDataBackend> backend_;
 
   WaitableEvent syncable_service_created_or_destroyed_;
 

chrome/browser/webdata/autocomplete_syncable_service.cc

@@ -23,6 +23,7 @@ using autofill::AutofillEntry;
 using autofill::AutofillKey;
 using autofill::AutofillTable;
 using autofill::AutofillWebDataService;
+using autofill::AutofillWebDataBackend;
 using content::BrowserThread;
 
 namespace {
@@ -92,14 +93,14 @@ void* UserDataKey() {
 }  // namespace
 
 AutocompleteSyncableService::AutocompleteSyncableService(
-    AutofillWebDataService* web_data_service)
-    : web_data_service_(web_data_service),
+    AutofillWebDataBackend* webdata_backend)
+    : webdata_backend_(webdata_backend),
       scoped_observer_(this),
       cull_expired_entries_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  DCHECK(web_data_service_);
+  DCHECK(webdata_backend_);
 
-  scoped_observer_.Add(web_data_service_);
+  scoped_observer_.Add(webdata_backend_);
 }
 
 AutocompleteSyncableService::~AutocompleteSyncableService() {
@@ -107,10 +108,11 @@ AutocompleteSyncableService::~AutocompleteSyncableService() {
 }
 
 // static
-void AutocompleteSyncableService::CreateForWebDataService(
-    AutofillWebDataService* web_data_service) {
+void AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
+    AutofillWebDataService* web_data_service,
+    AutofillWebDataBackend* webdata_backend) {
   web_data_service->GetDBUserData()->SetUserData(
-      UserDataKey(), new AutocompleteSyncableService(web_data_service));
+      UserDataKey(), new AutocompleteSyncableService(webdata_backend));
 }
 
 // static
@@ -121,7 +123,7 @@ AutocompleteSyncableService* AutocompleteSyncableService::FromWebDataService(
 }
 
 AutocompleteSyncableService::AutocompleteSyncableService()
-    : web_data_service_(NULL),
+    : webdata_backend_(NULL),
       scoped_observer_(this),
       cull_expired_entries_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
@@ -179,7 +181,7 @@ syncer::SyncMergeResult AutocompleteSyncableService::MergeDataAndStartSyncing(
     return merge_result;
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  webdata_backend_->NotifyOfMultipleAutofillChanges();
 
   syncer::SyncChangeList new_changes;
   for (AutocompleteEntryMap::iterator i = new_db_entries.begin();
@@ -193,7 +195,7 @@ syncer::SyncMergeResult AutocompleteSyncableService::MergeDataAndStartSyncing(
   if (cull_expired_entries_) {
     // This will schedule a deletion operation on the DB thread, which will
     // trigger a notification to propagate the deletion to Sync.
-    web_data_service_->RemoveExpiredFormElements();
+    webdata_backend_->RemoveExpiredFormElements();
   }
 
   merge_result.set_error(
@@ -296,12 +298,12 @@ syncer::SyncError AutocompleteSyncableService::ProcessSyncChanges(
         "Failed to update webdata.");
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  webdata_backend_->NotifyOfMultipleAutofillChanges();
 
   if (cull_expired_entries_) {
     // This will schedule a deletion operation on the DB thread, which will
     // trigger a notification to propagate the deletion to Sync.
-    web_data_service_->RemoveExpiredFormElements();
+    webdata_backend_->RemoveExpiredFormElements();
   }
 
   return list_processing_error;
@@ -324,7 +326,7 @@ void AutocompleteSyncableService::AutofillEntriesChanged(
 bool AutocompleteSyncableService::LoadAutofillData(
     std::vector<AutofillEntry>* entries) const {
   return AutofillTable::FromWebDatabase(
-      web_data_service_->GetDatabase())->GetAllAutofillEntries(entries);
+      webdata_backend_->GetDatabase())->GetAllAutofillEntries(entries);
 }
 
 bool AutocompleteSyncableService::SaveChangesToWebData(
@@ -333,7 +335,7 @@ bool AutocompleteSyncableService::SaveChangesToWebData(
 
   if (!new_entries.empty() &&
       !AutofillTable::FromWebDatabase(
-          web_data_service_->GetDatabase())->UpdateAutofillEntries(
+          webdata_backend_->GetDatabase())->UpdateAutofillEntries(
               new_entries)) {
     return false;
   }
@@ -407,7 +409,7 @@ void AutocompleteSyncableService::WriteAutofillEntry(
 syncer::SyncError AutocompleteSyncableService::AutofillEntryDelete(
     const sync_pb::AutofillSpecifics& autofill) {
   if (!AutofillTable::FromWebDatabase(
-          web_data_service_->GetDatabase())->RemoveFormElement(
+          webdata_backend_->GetDatabase())->RemoveFormElement(
               UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()))) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
@@ -426,11 +428,11 @@ void AutocompleteSyncableService::ActOnChanges(
       case AutofillChange::ADD:
       case AutofillChange::UPDATE: {
         std::vector<base::Time> timestamps;
-        if (!AutofillTable::FromWebDatabase(
-                web_data_service_->GetDatabase())->GetAutofillTimestamps(
-                    change->key().name(),
-                    change->key().value(),
-                    &timestamps)) {
+        WebDatabase* db = webdata_backend_->GetDatabase();
+        if (!AutofillTable::FromWebDatabase(db)->GetAutofillTimestamps(
+                change->key().name(),
+                change->key().value(),
+                &timestamps)) {
           NOTREACHED();
           return;
         }

chrome/browser/webdata/autocomplete_syncable_service.h

@@ -17,6 +17,7 @@
 #include "base/threading/non_thread_safe.h"
 #include "components/autofill/browser/webdata/autofill_change.h"
 #include "components/autofill/browser/webdata/autofill_entry.h"
+#include "components/autofill/browser/webdata/autofill_webdata_backend.h"
 #include "components/autofill/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/browser/webdata/autofill_webdata_service_observer.h"
 #include "sync/api/sync_change.h"
@@ -48,8 +49,9 @@ class AutocompleteSyncableService
 
   // Creates a new AutocompleteSyncableService and hangs it off of
   // |web_data_service|, which takes ownership.
-  static void CreateForWebDataService(
-      autofill::AutofillWebDataService* web_data_service);
+  static void CreateForWebDataServiceAndBackend(
+      autofill::AutofillWebDataService* web_data_service,
+      autofill::AutofillWebDataBackend* webdata_backend);
 
   // Retrieves the AutocompleteSyncableService stored on |web_data|.
   static AutocompleteSyncableService* FromWebDataService(
@@ -86,7 +88,7 @@ class AutocompleteSyncableService
 
  protected:
   explicit AutocompleteSyncableService(
-      autofill::AutofillWebDataService* web_data_service);
+      autofill::AutofillWebDataBackend* webdata_backend);
 
   // Helper to query WebDatabase for the current autocomplete state.
   // Made virtual for ease of mocking in the unit-test.
@@ -152,10 +154,10 @@ class AutocompleteSyncableService
   }
 
   // Lifetime of AutocompleteSyncableService object is shorter than
-  // |web_data_service_| passed to it.
-  autofill::AutofillWebDataService* web_data_service_;
+  // |autofill_webdata_backend_| passed to it.
+  autofill::AutofillWebDataBackend* webdata_backend_;
 
-  ScopedObserver<autofill::AutofillWebDataService, AutocompleteSyncableService>
+  ScopedObserver<autofill::AutofillWebDataBackend, AutocompleteSyncableService>
       scoped_observer_;
 
   // We receive ownership of |sync_processor_| in MergeDataAndStartSyncing() and

chrome/browser/webdata/autofill_profile_syncable_service.cc

@@ -48,15 +48,15 @@ void* UserDataKey() {
 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
 
 AutofillProfileSyncableService::AutofillProfileSyncableService(
-    AutofillWebDataService* web_data_service,
+    autofill::AutofillWebDataBackend* webdata_backend,
     const std::string& app_locale)
-    : web_data_service_(web_data_service),
+    : webdata_backend_(webdata_backend),
       app_locale_(app_locale),
       scoped_observer_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  DCHECK(web_data_service_);
+  DCHECK(webdata_backend_);
 
-  scoped_observer_.Add(web_data_service_);
+  scoped_observer_.Add(webdata_backend_);
 }
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
@@ -64,12 +64,13 @@ AutofillProfileSyncableService::~AutofillProfileSyncableService() {
 }
 
 // static
-void AutofillProfileSyncableService::CreateForWebDataService(
+void AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
     AutofillWebDataService* web_data_service,
+    autofill::AutofillWebDataBackend* webdata_backend,
     const std::string& app_locale) {
   web_data_service->GetDBUserData()->SetUserData(
       UserDataKey(),
-      new AutofillProfileSyncableService(web_data_service, app_locale));
+      new AutofillProfileSyncableService(webdata_backend, app_locale));
 }
 
 // static
@@ -81,7 +82,7 @@ AutofillProfileSyncableService::FromWebDataService(
 }
 
 AutofillProfileSyncableService::AutofillProfileSyncableService()
-    : web_data_service_(NULL),
+    : webdata_backend_(NULL),
       scoped_observer_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
@@ -191,7 +192,8 @@ AutofillProfileSyncableService::MergeDataAndStartSyncing(
         sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  if (webdata_backend_)
+    webdata_backend_->NotifyOfMultipleAutofillChanges();
 
   return merge_result;
 }
@@ -262,7 +264,8 @@ syncer::SyncError AutofillProfileSyncableService::ProcessSyncChanges(
         "Failed to update webdata.");
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  if (webdata_backend_)
+    webdata_backend_->NotifyOfMultipleAutofillChanges();
 
   return syncer::SyncError();
 }
@@ -583,7 +586,7 @@ bool AutofillProfileSyncableService::MergeProfile(
 }
 
 AutofillTable* AutofillProfileSyncableService::GetAutofillTable() const {
-  return AutofillTable::FromWebDatabase(web_data_service_->GetDatabase());
+  return AutofillTable::FromWebDatabase(webdata_backend_->GetDatabase());
 }
 
 void AutofillProfileSyncableService::InjectStartSyncFlare(

chrome/browser/webdata/autofill_profile_syncable_service.h

@@ -17,6 +17,7 @@
 #include "components/autofill/browser/autofill_type.h"
 #include "components/autofill/browser/webdata/autofill_change.h"
 #include "components/autofill/browser/webdata/autofill_entry.h"
+#include "components/autofill/browser/webdata/autofill_webdata_backend.h"
 #include "components/autofill/browser/webdata/autofill_webdata_service_observer.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
@@ -50,8 +51,9 @@ class AutofillProfileSyncableService
 
   // Creates a new AutofillProfileSyncableService and hangs it off of
   // |web_data_service|, which takes ownership.
-  static void CreateForWebDataService(
+  static void CreateForWebDataServiceAndBackend(
       autofill::AutofillWebDataService* web_data_service,
+      autofill::AutofillWebDataBackend* webdata_backend,
       const std::string& app_locale);
 
   // Retrieves the AutofillProfileSyncableService stored on |web_data_service|.
@@ -84,7 +86,7 @@ class AutofillProfileSyncableService
 
  protected:
   AutofillProfileSyncableService(
-      autofill::AutofillWebDataService* web_data_service,
+      autofill::AutofillWebDataBackend* webdata_backend,
       const std::string& app_locale);
 
   // A convenience wrapper of a bunch of state we pass around while
@@ -183,9 +185,9 @@ class AutofillProfileSyncableService
     sync_processor_.reset(sync_processor);
   }
 
-  autofill::AutofillWebDataService* web_data_service_;  // WEAK
+  autofill::AutofillWebDataBackend* webdata_backend_;  // WEAK
   std::string app_locale_;
-  ScopedObserver<autofill::AutofillWebDataService,
+  ScopedObserver<autofill::AutofillWebDataBackend,
                  AutofillProfileSyncableService> scoped_observer_;
 
   // Cached Autofill profiles. *Warning* deleted profiles are still in the

chrome/browser/webdata/web_data_service_factory.cc

@@ -42,17 +42,19 @@ void ProfileErrorCallback(sql::InitStatus status) {
 void InitSyncableServicesOnDBThread(
     scoped_refptr<AutofillWebDataService> autofill_web_data,
     const base::FilePath& profile_path,
-    const std::string& app_locale) {
+    const std::string& app_locale,
+    autofill::AutofillWebDataBackend* autofill_backend) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   // Currently only Autocomplete and Autofill profiles use the new Sync API, but
   // all the database data should migrate to this API over time.
-  AutocompleteSyncableService::CreateForWebDataService(autofill_web_data);
+  AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
+      autofill_web_data, autofill_backend);
   AutocompleteSyncableService::FromWebDataService(
       autofill_web_data)->InjectStartSyncFlare(
           sync_start_util::GetFlareForSyncableService(profile_path));
-  AutofillProfileSyncableService::CreateForWebDataService(
-      autofill_web_data, app_locale);
+  AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
+      autofill_web_data, autofill_backend, app_locale);
   AutofillProfileSyncableService::FromWebDataService(
       autofill_web_data)->InjectStartSyncFlare(
           sync_start_util::GetFlareForSyncableService(profile_path));
@@ -99,12 +101,11 @@ WebDataServiceWrapper::WebDataServiceWrapper(Profile* profile) {
       web_database_, base::Bind(&ProfileErrorCallback));
   web_data_->Init();
 
-  BrowserThread::PostTask(
-      BrowserThread::DB, FROM_HERE,
-      base::Bind(&InitSyncableServicesOnDBThread,
-                 autofill_web_data_,
-                 profile_path,
-                 g_browser_process->GetApplicationLocale()));
+autofill_web_data_->GetAutofillBackend(
+       base::Bind(&InitSyncableServicesOnDBThread,
+                  autofill_web_data_,
+                  profile_path,
+                  g_browser_process->GetApplicationLocale()));
 }
 
 WebDataServiceWrapper::~WebDataServiceWrapper() {

components/autofill/browser/webdata/autofill_webdata.h

@@ -49,7 +49,6 @@ class AutofillWebData {
   virtual void RemoveFormElementsAddedBetween(
       const base::Time& delete_begin, const base::Time& delete_end) = 0;
 
-  virtual void RemoveExpiredFormElements() = 0;
   virtual void RemoveFormValueForElementName(const base::string16& name,
                                              const base::string16& value) = 0;
 

components/autofill/browser/webdata/autofill_webdata_backend.h

@@ -29,7 +29,7 @@ class AutofillWebDataBackend {
       AutofillWebDataServiceObserverOnDBThread* observer) = 0;
 
   // Remove expired elements from the database and commit if needed.
-  virtual void RemoveExpiredFormElementsWrapper() = 0;
+  virtual void RemoveExpiredFormElements() = 0;
 
   // Notifies listeners on the UI thread that multiple changes have been made to
   // to Autofill records of the database.

components/autofill/browser/webdata/autofill_webdata_backend_impl.cc

@@ -50,9 +50,10 @@ WebDatabase* AutofillWebDataBackendImpl::GetDatabase() {
   return web_database_backend_->database();
 }
 
-void AutofillWebDataBackendImpl::RemoveExpiredFormElementsWrapper() {
+void AutofillWebDataBackendImpl::RemoveExpiredFormElements() {
   web_database_backend_->ExecuteWriteTask(
-      Bind(&AutofillWebDataBackendImpl::RemoveExpiredFormElements, this));
+      Bind(&AutofillWebDataBackendImpl::RemoveExpiredFormElementsImpl,
+           this));
 }
 
 void AutofillWebDataBackendImpl::NotifyOfMultipleAutofillChanges() {
@@ -125,25 +126,6 @@ WebDatabase::State AutofillWebDataBackendImpl::RemoveFormElementsAddedBetween(
   return WebDatabase::COMMIT_NOT_NEEDED;
 }
 
-WebDatabase::State AutofillWebDataBackendImpl::RemoveExpiredFormElements(
-    WebDatabase* db) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  AutofillChangeList changes;
-
-  if (AutofillTable::FromWebDatabase(db)->RemoveExpiredFormElements(&changes)) {
-    if (!changes.empty()) {
-      // Post the notifications including the list of affected keys.
-      // This is sent here so that work resulting from this notification
-      // will be done on the DB thread, and not the UI thread.
-      FOR_EACH_OBSERVER(AutofillWebDataServiceObserverOnDBThread,
-                        db_observer_list_,
-                        AutofillEntriesChanged(changes));
-    }
-    return WebDatabase::COMMIT_NEEDED;
-  }
-  return WebDatabase::COMMIT_NOT_NEEDED;
-}
-
 WebDatabase::State AutofillWebDataBackendImpl::RemoveFormValueForElementName(
     const base::string16& name, const base::string16& value, WebDatabase* db) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
@@ -349,6 +331,25 @@ WebDatabase::State AutofillWebDataBackendImpl::RemoveOriginURLsModifiedBetween(
   return WebDatabase::COMMIT_NOT_NEEDED;
 }
 
+WebDatabase::State AutofillWebDataBackendImpl::RemoveExpiredFormElementsImpl(
+    WebDatabase* db) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
+  AutofillChangeList changes;
+
+  if (AutofillTable::FromWebDatabase(db)->RemoveExpiredFormElements(&changes)) {
+    if (!changes.empty()) {
+      // Post the notifications including the list of affected keys.
+      // This is sent here so that work resulting from this notification
+      // will be done on the DB thread, and not the UI thread.
+      FOR_EACH_OBSERVER(AutofillWebDataServiceObserverOnDBThread,
+                        db_observer_list_,
+                        AutofillEntriesChanged(changes));
+    }
+    return WebDatabase::COMMIT_NEEDED;
+  }
+  return WebDatabase::COMMIT_NOT_NEEDED;
+}
+
 void AutofillWebDataBackendImpl::DestroyAutofillProfileResult(
     const WDTypedResult* result) {
   DCHECK(result->GetType() == AUTOFILL_PROFILES_RESULT);

components/autofill/browser/webdata/autofill_webdata_backend_impl.h

@@ -49,7 +49,7 @@ class AutofillWebDataBackendImpl
   virtual void RemoveObserver(
       AutofillWebDataServiceObserverOnDBThread* observer) OVERRIDE;
   virtual WebDatabase* GetDatabase() OVERRIDE;
-  virtual void RemoveExpiredFormElementsWrapper() OVERRIDE;
+  virtual void RemoveExpiredFormElements() OVERRIDE;
   virtual void NotifyOfMultipleAutofillChanges() OVERRIDE;
 
   // Adds form fields to the web database.
@@ -73,8 +73,6 @@ class AutofillWebDataBackendImpl
       const base::Time& delete_end,
       WebDatabase* db);
 
-  // Removes expired form elements recorded for Autocomplete from the database.
-  WebDatabase::State RemoveExpiredFormElements(WebDatabase* db);
 
   // Removes the Form-value |value| which has been entered in form input fields
   // named |name| from the database.
@@ -137,6 +135,8 @@ class AutofillWebDataBackendImpl
   friend class base::RefCountedThreadSafe<AutofillWebDataBackendImpl,
       content::BrowserThread::DeleteOnDBThread>;
 
+  WebDatabase::State RemoveExpiredFormElementsImpl(WebDatabase* db);
+
   // Callbacks to ensure that sensitive info is destroyed if request is
   // cancelled.
   void DestroyAutofillProfileResult(const WDTypedResult* result);

components/autofill/browser/webdata/autofill_webdata_service.cc

@@ -24,20 +24,6 @@ using content::BrowserThread;
 
 namespace autofill {
 
-// static
-void AutofillWebDataService::NotifyOfMultipleAutofillChanges(
-    AutofillWebDataService* web_data_service) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-
-  if (!web_data_service)
-    return;
-
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      Bind(&AutofillWebDataService::NotifyAutofillMultipleChangedOnUIThread,
-           make_scoped_refptr(web_data_service)));
-}
-
 AutofillWebDataService::AutofillWebDataService(
     scoped_refptr<WebDatabaseService> wdbs,
     const ProfileErrorCallback& callback)
@@ -98,12 +84,6 @@ void AutofillWebDataService::RemoveFormElementsAddedBetween(
            autofill_backend_, delete_begin, delete_end));
 }
 
-void AutofillWebDataService::RemoveExpiredFormElements() {
-  wdbs_->ScheduleDBTask(FROM_HERE,
-      Bind(&AutofillWebDataBackendImpl::RemoveExpiredFormElements,
-           autofill_backend_));
-}
-
 void AutofillWebDataService::RemoveFormValueForElementName(
     const base::string16& name, const base::string16& value) {
   wdbs_->ScheduleDBTask(FROM_HERE,

components/autofill/browser/webdata/autofill_webdata_service.h

@@ -48,14 +48,6 @@ class AutofillWebDataService : public AutofillWebData,
   static scoped_refptr<AutofillWebDataService> FromBrowserContext(
       content::BrowserContext* context);
 
-  // Notifies listeners on the UI thread that multiple changes have been made to
-  // to Autofill records of the database.
-  // NOTE: This method is intended to be called from the DB thread.  It
-  // it asynchronously notifies listeners on the UI thread.
-  // |web_data_service| may be NULL for testing purposes.
-  static void NotifyOfMultipleAutofillChanges(
-      AutofillWebDataService* web_data_service);
-
   // WebDataServiceBase implementation.
   virtual void ShutdownOnUIThread() OVERRIDE;
 
@@ -72,7 +64,6 @@ class AutofillWebDataService : public AutofillWebData,
       WebDataServiceConsumer* consumer) OVERRIDE;
   virtual void RemoveFormElementsAddedBetween(
       const base::Time& delete_begin, const base::Time& delete_end) OVERRIDE;
-  virtual void RemoveExpiredFormElements() OVERRIDE;
   virtual void RemoveFormValueForElementName(
       const base::string16& name,
       const base::string16& value) OVERRIDE;
@@ -112,8 +103,14 @@ class AutofillWebDataService : public AutofillWebData,
  protected:
   virtual ~AutofillWebDataService();
 
+  virtual void NotifyAutofillMultipleChangedOnUIThread();
+
   virtual void ShutdownOnDBThread();
 
+  base::WeakPtr<AutofillWebDataService> AsWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
  private:
   // This makes the destructor public, and thus allows us to aggregate
   // SupportsUserData. It is private by default to prevent incorrect
@@ -127,8 +124,6 @@ class AutofillWebDataService : public AutofillWebData,
     DISALLOW_COPY_AND_ASSIGN(SupportsUserDataAggregatable);
   };
 
-  void NotifyAutofillMultipleChangedOnUIThread();
-
   // Storage for user data to be accessed only on the DB thread. May
   // be used e.g. for SyncableService subclasses that need to be owned
   // by this object. Is created on first call to |GetDBUserData()|.