Moved WebDataService to ProfileKeyedService

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/prefs/pref_service.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/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 140 matching lines @@
 }
 
 // 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;
 
-  WebDataService* web_data_service =
-      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!web_data_service) {
+  scoped_refptr<WebDataService> web_data_service =
+      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  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);
     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);
-  WebDataService* web_data_service =
+  scoped_refptr<WebDataService> web_data_service =
       content::Source<WebDataService>(source).ptr();
 
-  DCHECK(web_data_service &&
-         web_data_service ==
-             profile_->GetWebDataService(Profile::EXPLICIT_ACCESS));
+  DCHECK(web_data_service.get() &&
+         web_data_service.get() == WebDataServiceFactory::GetForProfile(
+             profile_, Profile::EXPLICIT_ACCESS).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;
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  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);
 
   // 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;
   }
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // Make the update.
   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;
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // Remove the profile.
   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;
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  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);
 
   // 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;
   }
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // Make the update.
   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;
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // Remove the credit card.
   wds->RemoveCreditCard(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 CreditCard* PersonalDataManager::GetCreditCardByGUID(const std::string& guid) {
@@ skipping 65 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.
-  WebDataService* web_data_service =
-    profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!web_data_service)
+  scoped_refptr<WebDataService> web_data_service =
+      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  if (!web_data_service.get())
     return;
 
   LoadProfiles();
   LoadCreditCards();
 
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_AUTOFILL_MULTIPLE_CHANGED,
       content::Source<WebDataService>(web_data_service));
 }
@@ skipping 72 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);
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // 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());
   }
@@ skipping 29 matching lines @@
   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());
 
-  WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!wds)
+  scoped_refptr<WebDataService> wds = WebDataServiceFactory::GetForProfile(
+      profile_, Profile::EXPLICIT_ACCESS);
+  if (!wds.get())
     return;
 
   // 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());
   }
 
@@ skipping 17 matching lines @@
   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() {
-  WebDataService* web_data_service =
-      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!web_data_service) {
+  scoped_refptr<WebDataService> web_data_service =
+      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_profiles_query_);
 
   pending_profiles_query_ = 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() {
-  WebDataService* web_data_service =
-      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!web_data_service) {
+  scoped_refptr<WebDataService> web_data_service =
+      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_creditcards_query_);
 
   pending_creditcards_query_ = web_data_service->GetCreditCards(this);
 }
 
 void PersonalDataManager::ReceiveLoadedProfiles(WebDataService::Handle h,
@@ skipping 28 matching lines @@
 
   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) {
   if (*handle) {
-    WebDataService* web_data_service =
-        profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-    if (!web_data_service) {
+    scoped_refptr<WebDataService> web_data_service =
+        WebDataServiceFactory::GetForProfile(profile_,
+                                             Profile::EXPLICIT_ACCESS);
+    if (!web_data_service.get()) {
       NOTREACHED();
       return;
     }
     web_data_service->CancelRequest(*handle);
   }
   *handle = 0;
 }
 
 void PersonalDataManager::SaveImportedProfile(
     const AutofillProfile& imported_profile) {
@@ skipping 47 matching lines @@
   if (!merged)
     creditcards.push_back(imported_credit_card);
 
   SetCreditCards(&creditcards);
 }
 
 void PersonalDataManager::EmptyMigrationTrash() {
   if (!profile_ || profile_->IsOffTheRecord())
     return;
 
-  WebDataService* web_data_service =
-      profile_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-  if (!web_data_service) {
+  scoped_refptr<WebDataService> web_data_service =
+      WebDataServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
+  if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
   if (!sync_service)
     return;
 
   if (!sync_service->HasSyncSetupCompleted()) {
@@ skipping 16 matching lines @@
 }
 
 const AutofillMetrics* PersonalDataManager::metric_logger() const {
   return metric_logger_.get();
 }
 
 void PersonalDataManager::set_metric_logger(
     const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }