Use BrowserContext as key in API. Switch Autofill to use BC in place of Profile.

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 10 matching lines @@
 #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/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"
 
+using content::BrowserContext;
+
 namespace {
 
 template<typename T>
 class FormGroupMatchesByGUIDFunctor {
  public:
   explicit FormGroupMatchesByGUIDFunctor(const std::string& guid)
       : guid_(guid) {
   }
 
   bool operator()(const T& form_group) {
@@ skipping 117 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.
     ProfileSyncService* sync_service =
-        ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
+        ProfileSyncServiceFactory::GetInstance()->GetForProfile(
+            static_cast<Profile*>(browser_context_));
     if (sync_service && (!sync_service->HasSyncSetupCompleted() ||
-                         !PrefServiceBase::ForProfile(profile_)->GetBoolean(
-                             prefs::kSyncAutofill))) {
+                         !PrefServiceBase::ForContext(
+                             browser_context_)->GetBoolean(
+                                 prefs::kSyncAutofill))) {
       scoped_refptr<WebDataServiceBase> service =
-          WebDataServiceBase::ForProfile(profile_);
+          WebDataServiceBase::ForContext(browser_context_);
       if (service) {
         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())
+  if (!browser_context_ || browser_context_->IsOffTheRecord())
     return;
 
   scoped_refptr<WebDataServiceBase> web_data_service =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncService* sync_service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(
+          static_cast<Profile*>(browser_context_));
   if (!sync_service)
     return;
 
   if (sync_service->ShouldPushChanges()) {
     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<WebDataServiceBase> web_data_service =
       content::Source<WebDataServiceBase>(source).ptr();
 
   DCHECK(web_data_service.get() &&
-         web_data_service.get() == WebDataServiceBase::ForProfile(
-             profile_).get());
+         web_data_service.get() == WebDataServiceBase::ForContext(
+             browser_context_).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 102 matching lines @@
   if (imported_profile.get() || *imported_credit_card || merged_credit_card) {
     return true;
   } else {
     FOR_EACH_OBSERVER(PersonalDataManagerObserver, observers_,
                       OnInsufficientFormData());
     return false;
   }
 }
 
 void PersonalDataManager::AddProfile(const AutofillProfile& profile) {
-  if (profile_->IsOffTheRecord())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (profile.IsEmpty())
     return;
 
   // Don't add an existing profile.
   if (FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!wds.get())
     return;
 
   // Don't add a duplicate.
   if (FindByContents(web_profiles_, profile))
     return;
 
   // Add the new profile to the web database.
   AutofillWebData::ForService(wds)->AddAutofillProfile(profile);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
 void PersonalDataManager::UpdateProfile(const AutofillProfile& profile) {
-  if (profile_->IsOffTheRecord())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, profile.guid()))
     return;
 
   if (profile.IsEmpty()) {
     RemoveProfile(profile.guid());
     return;
   }
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!wds.get())
     return;
 
   // Make the update.
   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())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<AutofillProfile>(web_profiles_, guid))
     return;
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!wds.get())
     return;
 
   // Remove the profile.
   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())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (credit_card.IsEmpty())
     return;
 
   if (FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   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.
   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())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, credit_card.guid()))
     return;
 
   if (credit_card.IsEmpty()) {
     RemoveCreditCard(credit_card.guid());
     return;
   }
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!wds.get())
     return;
 
   // Make the update.
   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())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   if (!FindByGUID<CreditCard>(credit_cards_, guid))
     return;
 
   scoped_refptr<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!wds.get())
     return;
 
   // Remove the credit card.
   AutofillWebData::ForService(wds)->RemoveCreditCard(guid);
 
   // Refresh our local cache and send notifications to observers.
   Refresh();
 }
 
@@ skipping 18 matching lines @@
        iter != credit_cards_.end(); ++iter) {
     (*iter)->GetNonEmptyTypes(non_empty_types);
   }
 }
 
 bool PersonalDataManager::IsDataLoaded() const {
   return is_data_loaded_;
 }
 
 const std::vector<AutofillProfile*>& PersonalDataManager::profiles() const {
-  // |profile_| is NULL in AutofillManagerTest.
-  bool auxiliary_profiles_enabled = profile_ ?
-      PrefServiceBase::ForProfile(profile_)->GetBoolean(
+  // |browser_context_| is NULL in AutofillManagerTest.
+  bool auxiliary_profiles_enabled = browser_context_ ?
+      PrefServiceBase::ForContext(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 14 matching lines @@
 const std::vector<CreditCard*>& PersonalDataManager::credit_cards() const {
   return credit_cards_.get();
 }
 
 void PersonalDataManager::Refresh() {
   LoadProfiles();
   LoadCreditCards();
 }
 
 PersonalDataManager::PersonalDataManager()
-    : profile_(NULL),
+    : browser_context_(NULL),
       is_data_loaded_(false),
       pending_profiles_query_(0),
       pending_creditcards_query_(0),
       metric_logger_(new AutofillMetrics),
       has_logged_profile_count_(false) {
 }
 
-void PersonalDataManager::Init(Profile* profile) {
-  profile_ = profile;
+void PersonalDataManager::Init(BrowserContext* browser_context) {
+  browser_context_ = browser_context;
   metric_logger_->LogIsAutofillEnabledAtStartup(IsAutofillEnabled());
 
   // WebDataService may not be available in tests.
   scoped_refptr<WebDataServiceBase> web_data_service =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!web_data_service.get())
     return;
 
   LoadProfiles();
   LoadCreditCards();
 
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_AUTOFILL_MULTIPLE_CHANGED,
       content::Source<WebDataServiceBase>(web_data_service));
 }
 
 bool PersonalDataManager::IsAutofillEnabled() const {
-  return PrefServiceBase::ForProfile(profile_)->GetBoolean(
+  return PrefServiceBase::ForContext(browser_context_)->GetBoolean(
       prefs::kAutofillEnabled);
 }
 
 // static
 bool PersonalDataManager::IsValidLearnableProfile(
     const AutofillProfile& profile) {
   if (!IsMinimumAddress(profile))
     return false;
 
   string16 email = profile.GetInfo(EMAIL_ADDRESS);
@@ skipping 42 matching lines @@
   }
 
   // If the new profile was not merged with an existing one, add it to the list.
   if (!merged)
     merged_profiles->push_back(profile);
 
   return merged;
 }
 
 void PersonalDataManager::SetProfiles(std::vector<AutofillProfile>* profiles) {
-  if (profile_->IsOffTheRecord())
+  if (browser_context_->IsOffTheRecord())
     return;
 
   // Remove empty profiles from input.
   profiles->erase(
       std::remove_if(profiles->begin(), profiles->end(),
                      std::mem_fun_ref(&AutofillProfile::IsEmpty)),
       profiles->end());
 
   // 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<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   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()))
@@ skipping 21 matching lines @@
        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())
+  if (browser_context_->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<WebDataServiceBase> wds =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   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()))
       autofill_data->RemoveCreditCard((*iter)->guid());
@@ skipping 20 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_refptr<WebDataServiceBase> web_data_service =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_profiles_query_);
 
   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<WebDataServiceBase> web_data_service =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   CancelPendingQuery(&pending_creditcards_query_);
 
   pending_creditcards_query_ = AutofillWebData::ForService(
       web_data_service)->GetCreditCards(this);
 }
@@ skipping 32 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_refptr<WebDataServiceBase> web_data_service =
-        WebDataServiceBase::ForProfile(profile_);
+        WebDataServiceBase::ForContext(browser_context_);
     if (!web_data_service.get()) {
       NOTREACHED();
       return;
     }
     web_data_service->CancelRequest(*handle);
   }
   *handle = 0;
 }
 
 void PersonalDataManager::SaveImportedProfile(
     const AutofillProfile& imported_profile) {
-  if (profile_->IsOffTheRecord()) {
+  if (browser_context_->IsOffTheRecord()) {
     // The |IsOffTheRecord| check should happen earlier in the import process,
     // upon form submission.
     NOTREACHED();
     return;
   }
 
   // Don't save a web profile if the data in the profile is a subset of an
   // auxiliary profile.
   for (std::vector<AutofillProfile*>::const_iterator iter =
            auxiliary_profiles_.begin();
        iter != auxiliary_profiles_.end(); ++iter) {
     if (imported_profile.IsSubsetOf(**iter))
       return;
   }
 
   std::vector<AutofillProfile> profiles;
   MergeProfile(imported_profile, web_profiles_.get(), &profiles);
   SetProfiles(&profiles);
 }
 
 
 void PersonalDataManager::SaveImportedCreditCard(
     const CreditCard& imported_credit_card) {
   DCHECK(!imported_credit_card.number().empty());
-  if (profile_->IsOffTheRecord()) {
+  if (browser_context_->IsOffTheRecord()) {
     // The |IsOffTheRecord| check should happen earlier in the import process,
     // upon form submission.
     NOTREACHED();
     return;
   }
 
   // Set to true if |imported_credit_card| is merged into the credit card list.
   bool merged = false;
 
   std::vector<CreditCard> creditcards;
   for (std::vector<CreditCard*>::const_iterator card = credit_cards_.begin();
        card != credit_cards_.end();
        ++card) {
     // If |imported_credit_card| has not yet been merged, check whether it
     // should be with the current |card|.
     if (!merged && (*card)->UpdateFromImportedCard(imported_credit_card))
       merged = true;
 
     creditcards.push_back(**card);
   }
 
   if (!merged)
     creditcards.push_back(imported_credit_card);
 
   SetCreditCards(&creditcards);
 }
 
 void PersonalDataManager::EmptyMigrationTrash() {
-  if (!profile_ || profile_->IsOffTheRecord())
+  if (!browser_context_ || browser_context_->IsOffTheRecord())
     return;
 
   scoped_refptr<WebDataServiceBase> web_data_service =
-      WebDataServiceBase::ForProfile(profile_);
+      WebDataServiceBase::ForContext(browser_context_);
   if (!web_data_service.get()) {
     NOTREACHED();
     return;
   }
 
   ProfileSyncService* sync_service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(
+          static_cast<Profile*>(browser_context_));

[erikwright (departed), 2012/09/04 19:42:15]

Will this be permanent?

[Jói, 2012/09/04 20:10:25]

This goes away in the next change after, where instead we do
ProfileSyncServiceBase::ForContext(browser_context_);

   if (!sync_service)
     return;
 
   AutofillWebData* autofill_data =
       AutofillWebData::ForService(web_data_service);
   if (!sync_service->HasSyncSetupCompleted()) {
     autofill_data->EmptyMigrationTrash(false);
   } else if (sync_service->ShouldPushChanges()) {
     autofill_data->EmptyMigrationTrash(true);
   } else {
@@ skipping 12 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);
 }