Switching from ForXyz naming to FromXyz naming, for consistency.

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"
@@ skipping 149 matching lines @@
     std::copy(web_profiles_.begin(), web_profiles_.end(),
               profile_pointers.begin());
     AutofillProfile::AdjustInferredLabels(&profile_pointers);
     FOR_EACH_OBSERVER(PersonalDataManagerObserver, observers_,
                       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.
     ProfileSyncServiceBase* sync_service =
-        ProfileSyncServiceBase::ForContext(browser_context_);
+        ProfileSyncServiceBase::FromBrowserContext(browser_context_);
     if (sync_service && (!sync_service->HasSyncSetupCompleted() ||
-                         !PrefServiceBase::ForContext(
+                         !PrefServiceBase::FromBrowserContext(
                              browser_context_)->GetBoolean(
                                  prefs::kSyncAutofill))) {
       scoped_ptr<AutofillWebDataService> service(
-          AutofillWebDataService::ForContext(browser_context_));
+          AutofillWebDataService::FromBrowserContext(browser_context_));
       if (service.get())
         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 (!browser_context_ || browser_context_->IsOffTheRecord())
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncServiceBase* sync_service =
-      ProfileSyncServiceBase::ForContext(browser_context_);
+      ProfileSyncServiceBase::FromBrowserContext(browser_context_);
   if (!sync_service)
     return;
 
   if (sync_service->ShouldPushChanges()) {
     autofill_data->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);
 
   if (DCHECK_IS_ON()) {
     scoped_ptr<AutofillWebDataService> autofill_data(
-        AutofillWebDataService::ForContext(browser_context_));
+        AutofillWebDataService::FromBrowserContext(browser_context_));
 
     DCHECK(autofill_data.get() &&
            autofill_data->GetNotificationSource() == source);
   }
 
   Refresh();
 }
 
 bool PersonalDataManager::ImportFormData(
     const FormStructure& form,
@@ skipping 118 matching lines @@
     return;
 
   if (profile.IsEmpty())
     return;
 
   // Don't add an existing profile.
   if (FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Don't add a duplicate.
   if (FindByContents(web_profiles_, profile))
     return;
 
   // Add the new profile to the web database.
   autofill_data->AddAutofillProfile(profile);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::UpdateProfile(const AutofillProfile& profile) {
   if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
   if (profile.IsEmpty()) {
     RemoveProfile(profile.guid());
     return;
   }
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Make the update.
   autofill_data->UpdateAutofillProfile(profile);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::RemoveProfile(const std::string& guid) {
   if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, guid))
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Remove the profile.
   autofill_data->RemoveAutofillProfile(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
@@ skipping 11 matching lines @@
   if (browser_context_->IsOffTheRecord())
     return;
 
   if (credit_card.IsEmpty())
     return;
 
   if (FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Don't add a duplicate.
   if (FindByContents(credit_cards_, credit_card))
     return;
 
   // Add the new credit card to the web database.
   autofill_data->AddCreditCard(credit_card);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::UpdateCreditCard(const CreditCard& credit_card) {
   if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
   if (credit_card.IsEmpty()) {
     RemoveCreditCard(credit_card.guid());
     return;
   }
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Make the update.
   autofill_data->UpdateCreditCard(credit_card);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::RemoveCreditCard(const std::string& guid) {
   if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, guid))
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   // Remove the credit card.
   autofill_data->RemoveCreditCard(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
@@ skipping 20 matching lines @@
   }
 }
 
 bool PersonalDataManager::IsDataLoaded() const {
   return is_data_loaded_;
 }
 
 const std::vector<AutofillProfile*>& PersonalDataManager::profiles() const {
   // |browser_context_| is NULL in AutofillManagerTest.
   bool auxiliary_profiles_enabled = browser_context_ ?
-      PrefServiceBase::ForContext(browser_context_)->GetBoolean(
+      PrefServiceBase::FromBrowserContext(browser_context_)->GetBoolean(
           prefs::kAutofillAuxiliaryProfilesEnabled) :
       false;
   if (!auxiliary_profiles_enabled)
     return web_profiles();
 
 #if !defined(OS_MACOSX)
   NOTREACHED() << "Auxiliary profiles supported on Mac only";
 #endif
 
   profiles_.clear();
@@ skipping 28 matching lines @@
       metric_logger_(new AutofillMetrics),
       has_logged_profile_count_(false) {
 }
 
 void PersonalDataManager::Init(BrowserContext* browser_context) {
   browser_context_ = browser_context;
   metric_logger_->LogIsAutofillEnabledAtStartup(IsAutofillEnabled());
 
   // WebDataService may not be available in tests.
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get())
     return;
 
   LoadProfiles();
   LoadCreditCards();
 
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_AUTOFILL_MULTIPLE_CHANGED,
       autofill_data->GetNotificationSource());
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
-  return PrefServiceBase::ForContext(browser_context_)->GetBoolean(
+  return PrefServiceBase::FromBrowserContext(browser_context_)->GetBoolean(
       prefs::kAutofillEnabled);
 }
 
 // static
 bool PersonalDataManager::IsValidLearnableProfile(
     const AutofillProfile& profile) {
   if (!IsMinimumAddress(profile))
     return false;
 
   string16 email = profile.GetInfo(EMAIL_ADDRESS);
@@ skipping 61 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_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.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()))
       autofill_data->RemoveAutofillProfile((*iter)->guid());
@@ skipping 31 matching lines @@
     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_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.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()))
       autofill_data->RemoveCreditCard((*iter)->guid());
   }
@@ skipping 19 matching lines @@
        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_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_profiles_query_);
 
   pending_profiles_query_ = autofill_data->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_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_creditcards_query_);
 
   pending_creditcards_query_ = autofill_data->GetCreditCards(this);
 }
 
@@ skipping 31 matching lines @@
   for (std::vector<CreditCard*>::iterator iter = credit_cards.begin();
        iter != credit_cards.end(); ++iter) {
     credit_cards_.push_back(*iter);
   }
 }
 
 void PersonalDataManager::CancelPendingQuery(
     WebDataServiceBase::Handle* handle) {
   if (*handle) {
     scoped_ptr<AutofillWebDataService> autofill_data(
-        AutofillWebDataService::ForContext(browser_context_));
+        AutofillWebDataService::FromBrowserContext(browser_context_));
     if (!autofill_data.get()) {
       NOTREACHED();
       return;
     }
     autofill_data->CancelRequest(*handle);
   }
   *handle = 0;
 }
 
 void PersonalDataManager::SaveImportedProfile(
@@ skipping 49 matching lines @@
     creditcards.push_back(imported_credit_card);
 
   SetCreditCards(&creditcards);
 }
 
 void PersonalDataManager::EmptyMigrationTrash() {
   if (!browser_context_ || browser_context_->IsOffTheRecord())
     return;
 
   scoped_ptr<AutofillWebDataService> autofill_data(
-      AutofillWebDataService::ForContext(browser_context_));
+      AutofillWebDataService::FromBrowserContext(browser_context_));
   if (!autofill_data.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncServiceBase* sync_service =
-      ProfileSyncServiceBase::ForContext(browser_context_);
+      ProfileSyncServiceBase::FromBrowserContext(browser_context_);
   if (!sync_service)
     return;
 
   if (!sync_service->HasSyncSetupCompleted()) {
     autofill_data->EmptyMigrationTrash(false);
   } else if (sync_service->ShouldPushChanges()) {
     autofill_data->EmptyMigrationTrash(true);
   } else {
     // Install ourself as a listener so we can empty the trash once the
     // sync service becomes available.
@@ skipping 10 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);
 }