Download autocheckout whitelist and enable autocheckout for whitelisted sites only.

chrome/browser/autofill/autofill_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/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/prefs/public/pref_service_base.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/supports_user_data.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/api/infobars/infobar_service.h"
 #include "chrome/browser/api/sync/profile_sync_service_base.h"
+#include "chrome/browser/autofill/autocheckout/whitelist_manager.h"
 #include "chrome/browser/autofill/autocheckout_manager.h"
 #include "chrome/browser/autofill/autocheckout_infobar_delegate.h"
 #include "chrome/browser/autofill/autocomplete_history_manager.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_country.h"
 #include "chrome/browser/autofill/autofill_external_delegate.h"
 #include "chrome/browser/autofill/autofill_field.h"
 #include "chrome/browser/autofill/autofill_manager_delegate.h"
 #include "chrome/browser/autofill/autofill_metrics.h"
 #include "chrome/browser/autofill/autofill_profile.h"
@@ skipping 37 matching lines @@
 
 namespace {
 
 const char* kAutofillManagerWebContentsUserDataKey = "web_contents_autofill";
 
 // We only send a fraction of the forms to upload server.
 // The rate for positive/negative matches potentially could be different.
 const double kAutofillPositiveUploadRateDefaultValue = 0.20;
 const double kAutofillNegativeUploadRateDefaultValue = 0.20;
 
-const size_t kMaxRecentFormSignaturesToRemember = 3;
+const size_t kMaxRecentFormSignaturesToRemember = 0;

[Ilya Sherman, 2013/01/24 06:36:48]

Why did you change this variable?

[benquan, 2013/01/24 18:30:42]

ah, this change was for testing, reverted.

 
 // Set a conservative upper bound on the number of forms we are willing to
 // cache, simply to prevent unbounded memory consumption.
 const size_t kMaxFormCacheSize = 100;
 
 // Removes duplicate suggestions whilst preserving their original order.
 void RemoveDuplicateSuggestions(std::vector<string16>* values,
                                 std::vector<string16>* labels,
                                 std::vector<string16>* icons,
                                 std::vector<int>* unique_ids) {
@@ skipping 293 matching lines @@
     return false;
 
   if (web_contents()->GetBrowserContext()->IsOffTheRecord())
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return false;
 
   // Grab a copy of the form data.
-  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
+  scoped_ptr<FormStructure> submitted_form(
+      new FormStructure(form, IsAutocheckoutEnabled()));
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!submitted_form->ShouldBeParsed(true))
     return false;
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return false;
@@ skipping 39 matching lines @@
                    forms_loaded_timestamp_,
                    initial_interaction_timestamp_,
                    timestamp));
   }
 
   return true;
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp) {
+  DVLOG(1) << "Autocheckout is "
+           << (IsAutocheckoutEnabled() ? "enabled" : "disabled")
+           << " for " << web_contents()->GetURL();
   bool enabled = IsAutofillEnabled();
   if (!has_logged_autofill_enabled_) {
     metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
 
   if (!enabled)
     return;
 
   forms_loaded_timestamp_ = timestamp;
@@ skipping 413 matching lines @@
 
 void AutofillManager::OnDidEndTextFieldEditing() {
   if (external_delegate_)
     external_delegate_->DidEndTextFieldEditing();
 }
 
 void AutofillManager::OnClickFailed(autofill::AutocheckoutStatus status) {
   // TODO(ahutter): Plug into WalletClient.
 }
 
+bool AutofillManager::IsAutocheckoutEnabled() const {
+  if (!web_contents())
+    return false;
+
+  autocheckout::WhitelistManager* wm =
+      autocheckout::WhitelistManager::GetForBrowserContext(
+          web_contents()->GetBrowserContext());
+  return wm->IsAutocheckoutEnabled(web_contents()->GetURL());
+}
+
 bool AutofillManager::IsAutofillEnabled() const {
-  return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
+  return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled) ||
+      IsAutocheckoutEnabled();
 }
 
 void AutofillManager::SendAutofillTypePredictions(
     const std::vector<FormStructure*>& forms) const {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
            switches::kShowAutofillTypePredictions))
     return;
 
   RenderViewHost* host = web_contents()->GetRenderViewHost();
   if (!host)
@@ skipping 178 matching lines @@
 }
 
 bool AutofillManager::GetCachedFormAndField(const FormData& form,
                                             const FormFieldData& field,
                                             FormStructure** form_structure,
                                             AutofillField** autofill_field) {
   // Find the FormStructure that corresponds to |form|.
   // If we do not have this form in our cache but it is parseable, we'll add it
   // in the call to |UpdateCachedForm()|.
   if (!FindCachedForm(form, form_structure) &&
-      !FormStructure(form).ShouldBeParsed(false)) {
+      !FormStructure(form, IsAutocheckoutEnabled()).ShouldBeParsed(false)) {
     return false;
   }
 
   // Update the cached form to reflect any dynamic changes to the form data, if
   // necessary.
   if (!UpdateCachedForm(form, *form_structure, form_structure))
     return false;
 
   // No data to return if there are no auto-fillable fields.
   if (!(*form_structure)->autofill_count())
@@ skipping 26 matching lines @@
     needs_update = *cached_form->field(i) != live_form.fields[i];
   }
 
   if (!needs_update)
     return true;
 
   if (form_structures_.size() >= kMaxFormCacheSize)
     return false;
 
   // Add the new or updated form to our cache.
-  form_structures_.push_back(new FormStructure(live_form));
+  form_structures_.push_back(
+      new FormStructure(live_form, IsAutocheckoutEnabled()));
   *updated_form = *form_structures_.rbegin();
   (*updated_form)->DetermineHeuristicTypes(*metric_logger_);
 
   // If we have cached data, propagate it to the updated form.
   if (cached_form) {
     std::map<string16, const AutofillField*> cached_fields;
     for (size_t i = 0; i < cached_form->field_count(); ++i) {
       const AutofillField* field = cached_form->field(i);
       cached_fields[field->unique_name()] = field;
     }
@@ skipping 55 matching lines @@
   personal_data_->GetCreditCardSuggestions(
       type, field.value, values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   std::vector<FormStructure*> non_queryable_forms;
+  bool autocheckout_enabled = IsAutocheckoutEnabled();
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
-    scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
+    scoped_ptr<FormStructure> form_structure(
+        new FormStructure(*iter, autocheckout_enabled));
     if (!form_structure->ShouldBeParsed(false))
       continue;
 
     form_structure->DetermineHeuristicTypes(*metric_logger_);
 
     // Set aside forms with method GET or author-specified types, so that they
     // are not included in the query to the server.
     if (form_structure->ShouldBeCrowdsourced())
       form_structures_.push_back(form_structure.release());
     else
@@ skipping 77 matching lines @@
   *profile_guid = IDToGUID(profile_id);
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }