[rAc] Persist selection of newly added cards and addresses.

components/autofill/core/browser/personal_data_manager.cc

 // Copyright 2013 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 "components/autofill/core/browser/personal_data_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
@@ skipping 708 matching lines @@
     return false;
 
   // Reject profiles with invalid US zip information.
   if (profile.IsPresentButInvalid(ADDRESS_HOME_ZIP))
     return false;
 
   return true;
 }
 
 // static
-bool PersonalDataManager::MergeProfile(
+std::string PersonalDataManager::MergeProfile(
     const AutofillProfile& new_profile,
     const std::vector<AutofillProfile*>& existing_profiles,
     const std::string& app_locale,
     std::vector<AutofillProfile>* merged_profiles) {
   merged_profiles->clear();
 
   // Set to true if |existing_profiles| already contains an equivalent profile.
   bool matching_profile_found = false;
+  std::string guid = new_profile.guid();
 
   // If we have already saved this address, merge in any missing values.
   // Only merge with the first match.
   for (std::vector<AutofillProfile*>::const_iterator iter =
            existing_profiles.begin();
        iter != existing_profiles.end(); ++iter) {
     AutofillProfile* existing_profile = *iter;
     if (!matching_profile_found &&
         !new_profile.PrimaryValue().empty() &&
         StringToLowerASCII(existing_profile->PrimaryValue()) ==
             StringToLowerASCII(new_profile.PrimaryValue())) {
       // Unverified profiles should always be updated with the newer data,
       // whereas verified profiles should only ever be overwritten by verified
       // data.  If an automatically aggregated profile would overwrite a
       // verified profile, just drop it.
       matching_profile_found = true;
+      guid = existing_profile->guid();
       if (!existing_profile->IsVerified() || new_profile.IsVerified())
         existing_profile->OverwriteWithOrAddTo(new_profile, app_locale);
     }
     merged_profiles->push_back(*existing_profile);
   }
 
   // If the new profile was not merged with an existing one, add it to the list.
   if (!matching_profile_found)
     merged_profiles->push_back(new_profile);
 
-  return matching_profile_found;
+  return guid;
 }
 
 void PersonalDataManager::SetProfiles(std::vector<AutofillProfile>* profiles) {
   if (browser_context_->IsOffTheRecord())
     return;
 
   // Remove empty profiles from input.
   for (std::vector<AutofillProfile>::iterator it = profiles->begin();
        it != profiles->end();) {
     if (it->IsEmpty(app_locale_))
@@ skipping 180 matching lines @@
         AutofillWebDataService::FromBrowserContext(browser_context_));
     if (!autofill_data.get()) {
       NOTREACHED();
       return;
     }
     autofill_data->CancelRequest(*handle);
   }
   *handle = 0;
 }
 
-void PersonalDataManager::SaveImportedProfile(
+std::string PersonalDataManager::SaveImportedProfile(
     const AutofillProfile& imported_profile) {
   if (browser_context_->IsOffTheRecord())
-    return;
+    return std::string();
 
   // 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, app_locale_))
-      return;
+      return (*iter)->guid();
   }
 
   std::vector<AutofillProfile> profiles;
-  MergeProfile(imported_profile, web_profiles_.get(), app_locale_, &profiles);
+  std::string guid =
+      MergeProfile(imported_profile, web_profiles_.get(), app_locale_,
+                   &profiles);
   SetProfiles(&profiles);
+  return guid;
 }
 
 
-void PersonalDataManager::SaveImportedCreditCard(
+std::string PersonalDataManager::SaveImportedCreditCard(
     const CreditCard& imported_card) {
   DCHECK(!imported_card.number().empty());
   if (browser_context_->IsOffTheRecord())
-    return;
+    return std::string();
 
   // Set to true if |imported_card| is merged into the credit card list.
   bool merged = false;
 
+  std::string guid = imported_card.guid();
   std::vector<CreditCard> credit_cards;
   for (std::vector<CreditCard*>::const_iterator card = credit_cards_.begin();
        card != credit_cards_.end();
        ++card) {
     // If |imported_card| has not yet been merged, check whether it should be
     // with the current |card|.
-    if (!merged && (*card)->UpdateFromImportedCard(imported_card, app_locale_))
+    if (!merged &&
+        (*card)->UpdateFromImportedCard(imported_card, app_locale_)) {
+      guid = (*card)->guid();
       merged = true;
+    }
 
     credit_cards.push_back(**card);
   }
 
   if (!merged)
     credit_cards.push_back(imported_card);
 
   SetCreditCards(&credit_cards);
+  return guid;
 }
 
 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);
 }
 
 void PersonalDataManager::set_browser_context(
     content::BrowserContext* context) {
   browser_context_ = context;
 }
 
 }  // namespace autofill