Introduce a couple of abstract bases for WebDataService.

chrome/browser/autofill/personal_data_manager.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/autofill/personal_data_manager.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill-inl.h"
 #include "chrome/browser/autofill/autofill_field.h"
 #include "chrome/browser/autofill/autofill_metrics.h"
 #include "chrome/browser/autofill/autofill_regexes.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/autofill/personal_data_manager_observer.h"
 #include "chrome/browser/autofill/phone_number.h"
 #include "chrome/browser/autofill/phone_number_i18n.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/api/prefs/pref_service_base.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/webdata/autofill_entry.h"
-#include "chrome/browser/webdata/web_data_service.h"
-#include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_source.h"
 
 namespace {
 
 template<typename T>
 class FormGroupMatchesByGUIDFunctor {
  public:
@@ skipping 81 matching lines @@
 }
 
 }  // namespace
 
 PersonalDataManager::~PersonalDataManager() {
   CancelPendingQuery(&pending_profiles_query_);
   CancelPendingQuery(&pending_creditcards_query_);
 }
 
 void PersonalDataManager::OnWebDataServiceRequestDone(
-    WebDataService::Handle h,
+    WebDataServiceBase::Handle h,
     const WDTypedResult* result) {
   DCHECK(pending_profiles_query_ || pending_creditcards_query_);
 
   if (!result) {
     // Error from the web database.
     if (h == pending_creditcards_query_)
       pending_creditcards_query_ = 0;
     else if (h == pending_profiles_query_)
       pending_profiles_query_ = 0;
     return;
@@ skipping 24 matching lines @@
                       OnPersonalDataChanged());
 
     // As all Autofill data is ready, the Autocomplete data is ready as well.
     // If sync is not set, cull older entries of the autocomplete. Otherwise,
     // the entries will be culled when sync is connected.
     ProfileSyncService* sync_service =
         ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
     if (sync_service && (!sync_service->HasSyncSetupCompleted() ||
                          !PrefServiceBase::ForProfile(profile_)->GetBoolean(
                              prefs::kSyncAutofill))) {
-      scoped_refptr<WebDataService> web_data_service =
-          WebDataServiceFactory::GetForProfile(profile_,
-                                               Profile::EXPLICIT_ACCESS);
-      if (web_data_service)
-        web_data_service->RemoveExpiredFormElements();
+      scoped_refptr<WebDataServiceBase> service =
+          WebDataServiceBase::ForProfile(profile_);
+      if (service) {

[dhollowa, 2012/09/04 21:53:52]

nit: no need for {} with single-line if-body.

[Jói, 2012/09/06 01:17:27]

Done.

+        AutofillWebData::ForService(service)->RemoveExpiredFormElements();
+      }
     }
   }
 }
 
 void PersonalDataManager::SetObserver(PersonalDataManagerObserver* observer) {
   // TODO(dhollowa): RemoveObserver is for compatibility with old code, it
   // should be nuked.
   observers_.RemoveObserver(observer);
   observers_.AddObserver(observer);
 }
 
 void PersonalDataManager::RemoveObserver(
     PersonalDataManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // The |PersonalDataManager| is set up as a listener of the sync service in
 // |EmptyMigrationTrash| in the case where sync is not yet ready to receive
 // changes.  This method, |OnStateChange| acts as a deferred call to
 // |EmptyMigrationTrash| once the sync service becomes available.
 void PersonalDataManager::OnStateChanged() {
   if (!profile_ || profile_->IsOffTheRecord())
     return;
 
-  scoped_refptr<WebDataService> web_data_service =
-      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      WebDataServiceBase::ForProfile(profile_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
   if (!sync_service)
     return;
 
   if (sync_service->ShouldPushChanges()) {
-    web_data_service->EmptyMigrationTrash(true);
+    AutofillWebData::ForService(web_data_service)->EmptyMigrationTrash(true);
     sync_service->RemoveObserver(this);
   }
 }
 
 void PersonalDataManager::Shutdown() {
   CancelPendingQuery(&pending_profiles_query_);
   CancelPendingQuery(&pending_creditcards_query_);
   notification_registrar_.RemoveAll();
 }
 
 void PersonalDataManager::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_AUTOFILL_MULTIPLE_CHANGED);
-  scoped_refptr<WebDataService> web_data_service =
-      content::Source<WebDataService>(source).ptr();
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      content::Source<WebDataServiceBase>(source).ptr();
 
   DCHECK(web_data_service.get() &&
-         web_data_service.get() == WebDataServiceFactory::GetForProfile(
-             profile_, Profile::EXPLICIT_ACCESS).get());
+         web_data_service.get() == WebDataServiceBase::ForProfile(
+             profile_).get());
   Refresh();
 }
 
 bool PersonalDataManager::ImportFormData(
     const FormStructure& form,
     const CreditCard** imported_credit_card) {
   scoped_ptr<AutofillProfile> imported_profile(new AutofillProfile);
   scoped_ptr<CreditCard> local_imported_credit_card(new CreditCard);
 
   // Parse the form and construct a profile based on the information that is
@@ skipping 112 matching lines @@
   if (profile_->IsOffTheRecord())
     return;
 
   if (profile.IsEmpty())
     return;
 
   // Don't add an existing profile.
   if (FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =

[dhollowa, 2012/09/04 21:53:52]

Maybe some helpers like |autofill_data()| and |web_data_service()| would be nice
here too (like you have in autocomplete_history_manager.h) ?

[Jói, 2012/09/06 01:17:27]

Will look at this once we've finished discussing how to retrieve AutofillWebData
and ensure lifetime of the WebDataService through it (see large comment
somewhere in this email).

+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Don't add a duplicate.
   if (FindByContents(web_profiles_, profile))
     return;
 
   // Add the new profile to the web database.
-  wds->AddAutofillProfile(profile);
+  AutofillWebData::ForService(wds)->AddAutofillProfile(profile);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::UpdateProfile(const AutofillProfile& profile) {
   if (profile_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
   if (profile.IsEmpty()) {
     RemoveProfile(profile.guid());
     return;
   }
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Make the update.
-  wds->UpdateAutofillProfile(profile);
+  AutofillWebData::ForService(wds)->UpdateAutofillProfile(profile);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::RemoveProfile(const std::string& guid) {
   if (profile_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, guid))
     return;
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Remove the profile.
-  wds->RemoveAutofillProfile(guid);
+  AutofillWebData::ForService(wds)->RemoveAutofillProfile(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 AutofillProfile* PersonalDataManager::GetProfileByGUID(
     const std::string& guid) {
   for (std::vector<AutofillProfile*>::iterator iter = web_profiles_.begin();
        iter != web_profiles_.end(); ++iter) {
     if ((*iter)->guid() == guid)
       return *iter;
   }
   return NULL;
 }
 
 void PersonalDataManager::AddCreditCard(const CreditCard& credit_card) {
   if (profile_->IsOffTheRecord())
     return;
 
   if (credit_card.IsEmpty())
     return;
 
   if (FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Don't add a duplicate.
   if (FindByContents(credit_cards_, credit_card))
     return;
 
   // Add the new credit card to the web database.
-  wds->AddCreditCard(credit_card);
+  AutofillWebData::ForService(wds)->AddCreditCard(credit_card);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::UpdateCreditCard(const CreditCard& credit_card) {
   if (profile_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
   if (credit_card.IsEmpty()) {
     RemoveCreditCard(credit_card.guid());
     return;
   }
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Make the update.
-  wds->UpdateCreditCard(credit_card);
+  AutofillWebData::ForService(wds)->UpdateCreditCard(credit_card);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::RemoveCreditCard(const std::string& guid) {
   if (profile_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, guid))
     return;
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
 
   // Remove the credit card.
-  wds->RemoveCreditCard(guid);
+  AutofillWebData::ForService(wds)->RemoveCreditCard(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 CreditCard* PersonalDataManager::GetCreditCardByGUID(const std::string& guid) {
   for (std::vector<CreditCard*>::iterator iter = credit_cards_.begin();
        iter != credit_cards_.end(); ++iter) {
     if ((*iter)->guid() == guid)
       return *iter;
@@ skipping 63 matching lines @@
       pending_creditcards_query_(0),
       metric_logger_(new AutofillMetrics),
       has_logged_profile_count_(false) {
 }
 
 void PersonalDataManager::Init(Profile* profile) {
   profile_ = profile;
   metric_logger_->LogIsAutofillEnabledAtStartup(IsAutofillEnabled());
 
   // WebDataService may not be available in tests.
-  scoped_refptr<WebDataService> web_data_service =
-      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      WebDataServiceBase::ForProfile(profile_);
   if (!web_data_service.get())
     return;
 
   LoadProfiles();
   LoadCreditCards();
 
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_AUTOFILL_MULTIPLE_CHANGED,
-      content::Source<WebDataService>(web_data_service));
+      content::Source<WebDataServiceBase>(web_data_service));
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
   return PrefServiceBase::ForProfile(profile_)->GetBoolean(
       prefs::kAutofillEnabled);
 }
 
 // static
 bool PersonalDataManager::IsValidLearnableProfile(
     const AutofillProfile& profile) {
@@ skipping 64 matching lines @@
 
   // Ensure that profile labels are up to date.  Currently, sync relies on
   // labels to identify a profile.
   // TODO(dhollowa): We need to deprecate labels and update the way sync
   // identifies profiles.
   std::vector<AutofillProfile*> profile_pointers(profiles->size());
   std::transform(profiles->begin(), profiles->end(), profile_pointers.begin(),
       address_of<AutofillProfile>);
   AutofillProfile::AdjustInferredLabels(&profile_pointers);
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
+  AutofillWebData* autofill_data = AutofillWebData::ForService(wds);
 
   // Any profiles that are not in the new profile list should be removed from
   // the web database.
   for (std::vector<AutofillProfile*>::const_iterator iter =
            web_profiles_.begin();
        iter != web_profiles_.end(); ++iter) {
     if (!FindByGUID<AutofillProfile>(*profiles, (*iter)->guid()))
-      wds->RemoveAutofillProfile((*iter)->guid());
+      autofill_data->RemoveAutofillProfile((*iter)->guid());
   }
 
   // Update the web database with the existing profiles.
   for (std::vector<AutofillProfile>::iterator iter = profiles->begin();
        iter != profiles->end(); ++iter) {
     if (FindByGUID<AutofillProfile>(web_profiles_, iter->guid()))
-      wds->UpdateAutofillProfile(*iter);
+      autofill_data->UpdateAutofillProfile(*iter);
   }
 
   // Add the new profiles to the web database.  Don't add a duplicate.
   for (std::vector<AutofillProfile>::iterator iter = profiles->begin();
        iter != profiles->end(); ++iter) {
     if (!FindByGUID<AutofillProfile>(web_profiles_, iter->guid()) &&
         !FindByContents(web_profiles_, *iter))
-      wds->AddAutofillProfile(*iter);
+      autofill_data->AddAutofillProfile(*iter);
   }
 
   // Copy in the new profiles.
   web_profiles_.clear();
   for (std::vector<AutofillProfile>::iterator iter = profiles->begin();
        iter != profiles->end(); ++iter) {
     web_profiles_.push_back(new AutofillProfile(*iter));
   }
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::SetCreditCards(
     std::vector<CreditCard>* credit_cards) {
   if (profile_->IsOffTheRecord())
     return;
 
   // Remove empty credit cards from input.
   credit_cards->erase(
       std::remove_if(
           credit_cards->begin(), credit_cards->end(),
           std::mem_fun_ref(&CreditCard::IsEmpty)),
       credit_cards->end());
 
-  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> wds =
+      WebDataServiceBase::ForProfile(profile_);
   if (!wds.get())
     return;
+  AutofillWebData* autofill_data = AutofillWebData::ForService(wds);
 
   // Any credit cards that are not in the new credit card list should be
   // removed.
   for (std::vector<CreditCard*>::const_iterator iter = credit_cards_.begin();
        iter != credit_cards_.end(); ++iter) {
     if (!FindByGUID<CreditCard>(*credit_cards, (*iter)->guid()))
-      wds->RemoveCreditCard((*iter)->guid());
+      autofill_data->RemoveCreditCard((*iter)->guid());
   }
 
   // Update the web database with the existing credit cards.
   for (std::vector<CreditCard>::iterator iter = credit_cards->begin();
        iter != credit_cards->end(); ++iter) {
     if (FindByGUID<CreditCard>(credit_cards_, iter->guid()))
-      wds->UpdateCreditCard(*iter);
+      autofill_data->UpdateCreditCard(*iter);
   }
 
   // Add the new credit cards to the web database.  Don't add a duplicate.
   for (std::vector<CreditCard>::iterator iter = credit_cards->begin();
        iter != credit_cards->end(); ++iter) {
     if (!FindByGUID<CreditCard>(credit_cards_, iter->guid()) &&
         !FindByContents(credit_cards_, *iter))
-      wds->AddCreditCard(*iter);
+      autofill_data->AddCreditCard(*iter);
   }
 
   // Copy in the new credit cards.
   credit_cards_.clear();
   for (std::vector<CreditCard>::iterator iter = credit_cards->begin();
        iter != credit_cards->end(); ++iter) {
     credit_cards_.push_back(new CreditCard(*iter));
   }
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::LoadProfiles() {
-  scoped_refptr<WebDataService> web_data_service =
-      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      WebDataServiceBase::ForProfile(profile_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_profiles_query_);
 
-  pending_profiles_query_ = web_data_service->GetAutofillProfiles(this);
+  pending_profiles_query_ = AutofillWebData::ForService(
+      web_data_service)->GetAutofillProfiles(this);
 }
 
 // Win and Linux implementations do nothing.  Mac implementation fills in the
 // contents of |auxiliary_profiles_|.
 #if !defined(OS_MACOSX)
 void PersonalDataManager::LoadAuxiliaryProfiles() const {
 }
 #endif
 
 void PersonalDataManager::LoadCreditCards() {
-  scoped_refptr<WebDataService> web_data_service =
-      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      WebDataServiceBase::ForProfile(profile_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_creditcards_query_);
 
-  pending_creditcards_query_ = web_data_service->GetCreditCards(this);
+  pending_creditcards_query_ = AutofillWebData::ForService(
+      web_data_service)->GetCreditCards(this);
 }
 
-void PersonalDataManager::ReceiveLoadedProfiles(WebDataService::Handle h,
+void PersonalDataManager::ReceiveLoadedProfiles(WebDataServiceBase::Handle h,
                                                 const WDTypedResult* result) {
   DCHECK_EQ(pending_profiles_query_, h);
 
   pending_profiles_query_ = 0;
   web_profiles_.clear();
 
   const WDResult<std::vector<AutofillProfile*> >* r =
       static_cast<const WDResult<std::vector<AutofillProfile*> >*>(result);
 
   std::vector<AutofillProfile*> profiles = r->GetValue();
   for (std::vector<AutofillProfile*>::iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
     web_profiles_.push_back(*iter);
   }
 
   LogProfileCount();
   EmptyMigrationTrash();
 }
 
 void PersonalDataManager::ReceiveLoadedCreditCards(
-    WebDataService::Handle h, const WDTypedResult* result) {
+    WebDataServiceBase::Handle h, const WDTypedResult* result) {
   DCHECK_EQ(pending_creditcards_query_, h);
 
   pending_creditcards_query_ = 0;
   credit_cards_.clear();
 
   const WDResult<std::vector<CreditCard*> >* r =
       static_cast<const WDResult<std::vector<CreditCard*> >*>(result);
 
   std::vector<CreditCard*> credit_cards = r->GetValue();
   for (std::vector<CreditCard*>::iterator iter = credit_cards.begin();
        iter != credit_cards.end(); ++iter) {
     credit_cards_.push_back(*iter);
   }
 }
 
-void PersonalDataManager::CancelPendingQuery(WebDataService::Handle* handle) {
+void PersonalDataManager::CancelPendingQuery(
+    WebDataServiceBase::Handle* handle) {
   if (*handle) {
-    scoped_refptr<WebDataService> web_data_service =
-        WebDataServiceFactory::GetForProfile(profile_,
-                                             Profile::EXPLICIT_ACCESS);
+    scoped_refptr<WebDataServiceBase> web_data_service =
+        WebDataServiceBase::ForProfile(profile_);
     if (!web_data_service.get()) {
       NOTREACHED();
       return;
     }
     web_data_service->CancelRequest(*handle);
   }
   *handle = 0;
 }
 
 void PersonalDataManager::SaveImportedProfile(
@@ skipping 48 matching lines @@
   if (!merged)
     creditcards.push_back(imported_credit_card);
 
   SetCreditCards(&creditcards);
 }
 
 void PersonalDataManager::EmptyMigrationTrash() {
   if (!profile_ || profile_->IsOffTheRecord())
     return;
 
-  scoped_refptr<WebDataService> web_data_service =
-      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  scoped_refptr<WebDataServiceBase> web_data_service =
+      WebDataServiceBase::ForProfile(profile_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
   if (!sync_service)
     return;
 
+  AutofillWebData* autofill_data =
+      AutofillWebData::ForService(web_data_service);
   if (!sync_service->HasSyncSetupCompleted()) {
-    web_data_service->EmptyMigrationTrash(false);
+    autofill_data->EmptyMigrationTrash(false);
   } else if (sync_service->ShouldPushChanges()) {
-    web_data_service->EmptyMigrationTrash(true);
+    autofill_data->EmptyMigrationTrash(true);
   } else {
     // Install ourself as a listener so we can empty the trash once the
     // sync service becomes available.
     if (!sync_service->HasObserver(this))
       sync_service->AddObserver(this);
   }
 }
 
 void PersonalDataManager::LogProfileCount() const {
   if (!has_logged_profile_count_) {
     metric_logger_->LogStoredProfileCount(web_profiles_.size());
     has_logged_profile_count_ = true;
   }
 }
 
 const AutofillMetrics* PersonalDataManager::metric_logger() const {
   return metric_logger_.get();
 }
 
 void PersonalDataManager::set_metric_logger(
     const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }