Download autocheckout whitelist and enable autocheckout for whitelisted sites only.

chrome/browser/autofill/autofill_manager_unittest.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 <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 599 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
 }  // namespace
 
 class AutofillManagerTest : public ChromeRenderViewHostTestHarness {
  public:
   AutofillManagerTest()
       : ChromeRenderViewHostTestHarness(),
         ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE) {
+        file_thread_(BrowserThread::FILE),
+        io_thread_(BrowserThread::IO) {
   }
 
   virtual ~AutofillManagerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    Profile* profile = CreateProfile();
+    TestingProfile* profile = CreateProfile();
+    profile->CreateRequestContext();
     browser_context_.reset(profile);
     PersonalDataManagerFactory::GetInstance()->SetTestingFactory(
         profile, TestPersonalDataManager::Build);
 
     ChromeRenderViewHostTestHarness::SetUp();
+    io_thread_.StartIOThread();
     TabAutofillManagerDelegate::CreateForWebContents(web_contents());
     personal_data_.SetBrowserContext(profile);
     autofill_manager_ = new TestAutofillManager(
         web_contents(),
         TabAutofillManagerDelegate::FromWebContents(web_contents()),
         &personal_data_);
 
     file_thread_.Start();
   }
 
   virtual void TearDown() OVERRIDE {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed. Also, a real
     // AutofillManager is tied to the lifetime of the WebContents, so it must
     // be destroyed at the destruction of the WebContents.
     autofill_manager_ = NULL;
     file_thread_.Stop();
     ChromeRenderViewHostTestHarness::TearDown();
+    io_thread_.Stop();
   }
 
   virtual TestingProfile* CreateProfile() {
     return new TestingProfile();
   }
 
   void UpdatePasswordGenerationState(bool new_renderer) {
     autofill_manager_->UpdatePasswordGenerationState(NULL, new_renderer);
   }
 
@@ skipping 78 matching lines @@
     if (results)
       *results = autofill_param.b;
 
     process()->sink().ClearMessages();
     return true;
   }
 
  protected:
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
+  content::TestBrowserThread io_thread_;
 
   scoped_refptr<TestAutofillManager> autofill_manager_;
   TestPersonalDataManager personal_data_;
 
   // Used when we want an off the record profile. This will store the original
   // profile from which the off the record profile is derived.
   scoped_ptr<Profile> other_browser_context_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AutofillManagerTest);
 };
 
 class IncognitoAutofillManagerTest : public AutofillManagerTest {
  public:
   IncognitoAutofillManagerTest() {}
   virtual ~IncognitoAutofillManagerTest() {}
 
   virtual TestingProfile* CreateProfile() OVERRIDE {
     // Create an incognito profile.
     TestingProfile::Builder builder;
     builder.SetOffTheRecord();
     return builder.Build().release();
   }
 };
 
 class TestFormStructure : public FormStructure {
  public:
-  explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
+  explicit TestFormStructure(const FormData& form)
+      : FormStructure(form, std::string()) {}
   virtual ~TestFormStructure() {}
 
   void SetFieldTypes(const std::vector<AutofillFieldType>& heuristic_types,
                      const std::vector<AutofillFieldType>& server_types) {
     ASSERT_EQ(field_count(), heuristic_types.size());
     ASSERT_EQ(field_count(), server_types.size());
 
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* form_field = field(i);
       ASSERT_TRUE(form_field);
@@ skipping 1844 matching lines @@
 // Test that the form signature for an uploaded form always matches the form
 // signature from the query.
 TEST_F(AutofillManagerTest, FormSubmittedWithDifferentFields) {
   // Set up our form data.
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // Cache the expected form signature.
-  std::string signature = FormStructure(form).FormSignature();
+  std::string signature = FormStructure(form, std::string()).FormSignature();
 
   // Change the structure of the form prior to submission.
   // Websites would typically invoke JavaScript either on page load or on form
   // submit to achieve this.
   form.fields.pop_back();
   FormFieldData field = form.fields[3];
   form.fields[3] = form.fields[7];
   form.fields[7] = field;
 
   // Simulate form submission.
@@ skipping 563 matching lines @@
 
   FormData form;
   CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);  // should call the delegate's OnQuery()
 
   autofill_manager_->SetExternalDelegate(NULL);
 }