Hook up Autofill Backend interface to SyncableServices

chrome/browser/webdata/autocomplete_syncable_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/webdata/autocomplete_syncable_service.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "components/autofill/browser/webdata/autofill_table.h"
 #include "components/autofill/browser/webdata/autofill_webdata_service.h"
 #include "components/webdata/common/web_database.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 
 using autofill::AutofillChange;
 using autofill::AutofillChangeList;
 using autofill::AutofillEntry;
 using autofill::AutofillKey;
 using autofill::AutofillTable;
 using autofill::AutofillWebDataService;
+using autofill::AutofillWebDataBackend;
 using content::BrowserThread;
 
 namespace {
 
 const char kAutofillEntryNamespaceTag[] = "autofill_entry|";
 
 // Merges timestamps from the |autofill| entry and |timestamps|. Returns
 // true if they were different, false if they were the same.
 // All of the timestamp vectors are assummed to be sorted, resulting vector is
 // sorted as well. Only two timestamps - the earliest and the latest are stored.
@@ skipping 49 matching lines @@
 void* UserDataKey() {
   // Use the address of a static that COMDAT folding won't ever fold
   // with something else.
   static int user_data_key = 0;
   return reinterpret_cast<void*>(&user_data_key);
 }
 
 }  // namespace
 
 AutocompleteSyncableService::AutocompleteSyncableService(
-    AutofillWebDataService* web_data_service)
-    : web_data_service_(web_data_service),
+    AutofillWebDataBackend* autofill_webdata_backend)
+    : autofill_webdata_backend_(autofill_webdata_backend),
       scoped_observer_(this),
       cull_expired_entries_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
-  DCHECK(web_data_service_);
+  DCHECK(autofill_webdata_backend_);
 
-  scoped_observer_.Add(web_data_service_);
+  scoped_observer_.Add(autofill_webdata_backend_);
 }
 
 AutocompleteSyncableService::~AutocompleteSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
 void AutocompleteSyncableService::CreateForWebDataService(
-    AutofillWebDataService* web_data_service) {
+    AutofillWebDataService* web_data_service,
+    AutofillWebDataBackend* autofill_webdata_backend) {
   web_data_service->GetDBUserData()->SetUserData(
-      UserDataKey(), new AutocompleteSyncableService(web_data_service));
+      UserDataKey(), new AutocompleteSyncableService(autofill_webdata_backend));
 }
 
 // static
 AutocompleteSyncableService* AutocompleteSyncableService::FromWebDataService(
     AutofillWebDataService* web_data_service) {
   return static_cast<AutocompleteSyncableService*>(
       web_data_service->GetDBUserData()->GetUserData(UserDataKey()));
 }
 
 AutocompleteSyncableService::AutocompleteSyncableService()
-    : web_data_service_(NULL),
+    : autofill_webdata_backend_(NULL),
       scoped_observer_(this),
       cull_expired_entries_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 }
 
 void AutocompleteSyncableService::InjectStartSyncFlare(
     const syncer::SyncableService::StartSyncFlare& flare) {
   flare_ = flare;
 }
 
@@ skipping 37 matching lines @@
     CreateOrUpdateEntry(*sync_iter, &new_db_entries, &new_synced_entries);
   }
 
   if (!SaveChangesToWebData(new_synced_entries)) {
     merge_result.set_error(error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata."));
     return merge_result;
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  autofill_webdata_backend_->NotifyOfMultipleAutofillChanges();
 
   syncer::SyncChangeList new_changes;
   for (AutocompleteEntryMap::iterator i = new_db_entries.begin();
        i != new_db_entries.end(); ++i) {
     new_changes.push_back(
         syncer::SyncChange(FROM_HERE,
                            i->second.first,
                            CreateSyncData(*(i->second.second))));
   }
 
   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();
+    autofill_webdata_backend_->RemoveExpiredFormElementsWrapper();

[Ilya Sherman, 2013/05/13 23:44:47]

nit: Seems weird for this method, which is part of the public API, to have a
"Wrapper()" suffix.

[Cait (Slow), 2013/05/14 22:30:08]

Agreed. Since this is the only place we call this method from, I've renamed it
(and removed the corresponding method on AutofillWebData, since this is only
getting called from the DB thread) -- WDYT? 

[Ilya Sherman, 2013/05/14 23:03:15]

Much nicer, thanks :)

   }
 
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   return merge_result;
 }
 
 void AutocompleteSyncableService::StopSyncing(syncer::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(syncer::AUTOFILL, type);
@@ skipping 82 matching lines @@
                  syncer::SyncChange::ChangeTypeToString(i->change_type()));
     }
   }
 
   if (!SaveChangesToWebData(new_entries)) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Failed to update webdata.");
   }
 
-  AutofillWebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  autofill_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();
+    autofill_webdata_backend_->RemoveExpiredFormElementsWrapper();
   }
 
   return list_processing_error;
 }
 
 void AutocompleteSyncableService::AutofillEntriesChanged(
     const AutofillChangeList& changes) {
   // Check if sync is on. If we recieve this notification prior to sync being
   // started, we'll notify sync to start as soon as it can and later process
   // all entries when MergeData..() is called. If we receive this notification
   // sync has exited, it will be synced next time Chrome starts.
   if (sync_processor_.get()) {
     ActOnChanges(changes);
   } else if (!flare_.is_null()) {
     flare_.Run(syncer::AUTOFILL);
     flare_.Reset();
   }
 }
 
 bool AutocompleteSyncableService::LoadAutofillData(
     std::vector<AutofillEntry>* entries) const {
   return AutofillTable::FromWebDatabase(
-      web_data_service_->GetDatabase())->GetAllAutofillEntries(entries);
+      autofill_webdata_backend_->GetDatabase())->GetAllAutofillEntries(
+          entries);
 }
 
 bool AutocompleteSyncableService::SaveChangesToWebData(
     const std::vector<AutofillEntry>& new_entries) {
   DCHECK(CalledOnValidThread());
 
   if (!new_entries.empty() &&
       !AutofillTable::FromWebDatabase(
-          web_data_service_->GetDatabase())->UpdateAutofillEntries(
+         autofill_webdata_backend_->GetDatabase())->UpdateAutofillEntries(
               new_entries)) {
     return false;
   }
   return true;
 }
 
 // Creates or updates an autocomplete entry based on |data|.
 void AutocompleteSyncableService::CreateOrUpdateEntry(
     const syncer::SyncData& data,
     AutocompleteEntryMap* loaded_data,
@@ skipping 53 matching lines @@
   const std::vector<base::Time>& ts(entry.timestamps());
   for (std::vector<base::Time>::const_iterator timestamp = ts.begin();
        timestamp != ts.end(); ++timestamp) {
     autofill->add_usage_timestamp(timestamp->ToInternalValue());
   }
 }
 
 syncer::SyncError AutocompleteSyncableService::AutofillEntryDelete(
     const sync_pb::AutofillSpecifics& autofill) {
   if (!AutofillTable::FromWebDatabase(
-          web_data_service_->GetDatabase())->RemoveFormElement(
+          autofill_webdata_backend_->GetDatabase())->RemoveFormElement(
               UTF8ToUTF16(autofill.name()), UTF8ToUTF16(autofill.value()))) {
     return error_handler_->CreateAndUploadError(
         FROM_HERE,
         "Could not remove autocomplete entry from WebDatabase.");
   }
   return syncer::SyncError();
 }
 
 void AutocompleteSyncableService::ActOnChanges(
      const AutofillChangeList& changes) {
   DCHECK(sync_processor_.get());
   syncer::SyncChangeList new_changes;
   for (AutofillChangeList::const_iterator change = changes.begin();
        change != changes.end(); ++change) {
     switch (change->type()) {
       case AutofillChange::ADD:
       case AutofillChange::UPDATE: {
         std::vector<base::Time> timestamps;
-        if (!AutofillTable::FromWebDatabase(
-                web_data_service_->GetDatabase())->GetAutofillTimestamps(
+        WebDatabase* db = autofill_webdata_backend_->GetDatabase();
+        if (!AutofillTable::FromWebDatabase(db)->GetAutofillTimestamps(
                     change->key().name(),
                     change->key().value(),
                     &timestamps)) {

[Ilya Sherman, 2013/05/13 23:44:47]

nit: De-indent each of these lines four spaces.

[Cait (Slow), 2013/05/14 22:30:08]

Done.

           NOTREACHED();
           return;
         }
         AutofillEntry entry(change->key(), timestamps);
         syncer::SyncChange::SyncChangeType change_type =
            (change->type() == AutofillChange::ADD) ?
             syncer::SyncChange::ACTION_ADD :
             syncer::SyncChange::ACTION_UPDATE;
         new_changes.push_back(syncer::SyncChange(FROM_HERE,
                                                  change_type,
@@ skipping 37 matching lines @@
                            UTF16ToUTF8(entry.key().value())));
   return syncer::SyncData::CreateLocalData(tag, tag, autofill_specifics);
 }
 
 // static
 std::string AutocompleteSyncableService::KeyToTag(const std::string& name,
                                                   const std::string& value) {
   std::string ns(kAutofillEntryNamespaceTag);
   return ns + net::EscapePath(name) + "|" + net::EscapePath(value);
 }