Home | History | Annotate | Download | only in autofill
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <map>
      6 
      7 #include "base/bind.h"
      8 #include "base/command_line.h"
      9 #include "base/guid.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/prefs/pref_service.h"
     13 #include "base/run_loop.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/string_piece.h"
     16 #include "base/strings/utf_string_conversions.h"
     17 #include "base/tuple.h"
     18 #include "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
     19 #include "chrome/browser/ui/autofill/autofill_dialog_view.h"
     20 #include "chrome/browser/ui/autofill/generated_credit_card_bubble_controller.h"
     21 #include "chrome/browser/ui/autofill/mock_new_credit_card_bubble_controller.h"
     22 #include "chrome/browser/ui/autofill/test_generated_credit_card_bubble_controller.h"
     23 #include "chrome/browser/webdata/web_data_service_factory.h"
     24 #include "chrome/common/pref_names.h"
     25 #include "chrome/common/render_messages.h"
     26 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
     27 #include "chrome/test/base/scoped_testing_local_state.h"
     28 #include "chrome/test/base/testing_browser_process.h"
     29 #include "chrome/test/base/testing_profile.h"
     30 #include "components/autofill/content/browser/risk/proto/fingerprint.pb.h"
     31 #include "components/autofill/content/browser/wallet/full_wallet.h"
     32 #include "components/autofill/content/browser/wallet/gaia_account.h"
     33 #include "components/autofill/content/browser/wallet/instrument.h"
     34 #include "components/autofill/content/browser/wallet/mock_wallet_client.h"
     35 #include "components/autofill/content/browser/wallet/wallet_address.h"
     36 #include "components/autofill/content/browser/wallet/wallet_service_url.h"
     37 #include "components/autofill/content/browser/wallet/wallet_test_util.h"
     38 #include "components/autofill/core/browser/autofill_metrics.h"
     39 #include "components/autofill/core/browser/autofill_test_utils.h"
     40 #include "components/autofill/core/browser/test_personal_data_manager.h"
     41 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
     42 #include "components/autofill/core/common/autofill_switches.h"
     43 #include "components/autofill/core/common/form_data.h"
     44 #include "components/user_prefs/user_prefs.h"
     45 #include "content/public/browser/web_contents.h"
     46 #include "content/public/test/mock_render_process_host.h"
     47 #include "google_apis/gaia/google_service_auth_error.h"
     48 #include "testing/gmock/include/gmock/gmock.h"
     49 #include "testing/gtest/include/gtest/gtest.h"
     50 
     51 #if defined(OS_WIN)
     52 #include "ui/base/win/scoped_ole_initializer.h"
     53 #endif
     54 
     55 namespace autofill {
     56 
     57 namespace {
     58 
     59 using testing::_;
     60 
     61 const char kFakeEmail[] = "user (at) chromium.org";
     62 const char kFakeFingerprintEncoded[] = "CgVaAwiACA==";
     63 const char kEditedBillingAddress[] = "123 edited billing address";
     64 const char* kFieldsFromPage[] =
     65     { "email",
     66       "cc-name",
     67       "cc-number",
     68       "cc-exp-month",
     69       "cc-exp-year",
     70       "cc-csc",
     71       "billing name",
     72       "billing address-line1",
     73       "billing locality",
     74       "billing region",
     75       "billing postal-code",
     76       "billing country",
     77       "billing tel",
     78       "shipping name",
     79       "shipping address-line1",
     80       "shipping locality",
     81       "shipping region",
     82       "shipping postal-code",
     83       "shipping country",
     84       "shipping tel",
     85     };
     86 const char kSettingsOrigin[] = "Chrome settings";
     87 const char kTestCCNumberAmex[] = "376200000000002";
     88 const char kTestCCNumberVisa[] = "4111111111111111";
     89 const char kTestCCNumberMaster[] = "5555555555554444";
     90 const char kTestCCNumberDiscover[] = "6011111111111117";
     91 const char kTestCCNumberIncomplete[] = "4111111111";
     92 // Credit card number fails Luhn check.
     93 const char kTestCCNumberInvalid[] = "4111111111111112";
     94 
     95 // Copies the initial values from |inputs| into |outputs|.
     96 void CopyInitialValues(const DetailInputs& inputs, FieldValueMap* outputs) {
     97   for (size_t i = 0; i < inputs.size(); ++i) {
     98     const DetailInput& input = inputs[i];
     99     (*outputs)[input.type] = input.initial_value;
    100   }
    101 }
    102 
    103 scoped_ptr<wallet::WalletItems> CompleteAndValidWalletItems() {
    104   scoped_ptr<wallet::WalletItems> items =
    105       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
    106   items->AddAccount(wallet::GetTestGaiaAccount());
    107   items->AddInstrument(wallet::GetTestMaskedInstrument());
    108   items->AddAddress(wallet::GetTestShippingAddress());
    109   return items.Pass();
    110 }
    111 
    112 scoped_ptr<risk::Fingerprint> GetFakeFingerprint() {
    113   scoped_ptr<risk::Fingerprint> fingerprint(new risk::Fingerprint());
    114   // Add some data to the proto, else the encoded content is empty.
    115   fingerprint->mutable_machine_characteristics()->mutable_screen_size()->
    116       set_width(1024);
    117   return fingerprint.Pass();
    118 }
    119 
    120 bool HasAnyError(const ValidityMessages& messages, ServerFieldType field) {
    121   return !messages.GetMessageOrDefault(field).text.empty();
    122 }
    123 
    124 bool HasUnsureError(const ValidityMessages& messages, ServerFieldType field) {
    125   const ValidityMessage& message = messages.GetMessageOrDefault(field);
    126   return !message.text.empty() && !message.sure;
    127 }
    128 
    129 class TestAutofillDialogView : public AutofillDialogView {
    130  public:
    131   TestAutofillDialogView()
    132       : updates_started_(0), save_details_locally_checked_(true) {}
    133   virtual ~TestAutofillDialogView() {}
    134 
    135   virtual void Show() OVERRIDE {}
    136   virtual void Hide() OVERRIDE {}
    137 
    138   virtual void UpdatesStarted() OVERRIDE {
    139     updates_started_++;
    140   }
    141 
    142   virtual void UpdatesFinished() OVERRIDE {
    143     updates_started_--;
    144     EXPECT_GE(updates_started_, 0);
    145   }
    146 
    147   virtual void UpdateNotificationArea() OVERRIDE {
    148     EXPECT_GE(updates_started_, 1);
    149   }
    150 
    151   virtual void UpdateAccountChooser() OVERRIDE {
    152     EXPECT_GE(updates_started_, 1);
    153   }
    154 
    155   virtual void UpdateButtonStrip() OVERRIDE {
    156     EXPECT_GE(updates_started_, 1);
    157   }
    158 
    159   virtual void UpdateOverlay() OVERRIDE {
    160     EXPECT_GE(updates_started_, 1);
    161   }
    162 
    163   virtual void UpdateDetailArea() OVERRIDE {
    164     EXPECT_GE(updates_started_, 1);
    165   }
    166 
    167   virtual void UpdateSection(DialogSection section) OVERRIDE {
    168     EXPECT_GE(updates_started_, 1);
    169   }
    170 
    171   virtual void UpdateErrorBubble() OVERRIDE {
    172     EXPECT_GE(updates_started_, 1);
    173   }
    174 
    175   virtual void FillSection(DialogSection section,
    176                            const DetailInput& originating_input) OVERRIDE {};
    177   virtual void GetUserInput(DialogSection section, FieldValueMap* output)
    178       OVERRIDE {
    179     *output = outputs_[section];
    180   }
    181   virtual TestableAutofillDialogView* GetTestableView() OVERRIDE {
    182     return NULL;
    183   }
    184 
    185   virtual base::string16 GetCvc() OVERRIDE { return base::string16(); }
    186   virtual bool HitTestInput(const DetailInput& input,
    187                             const gfx::Point& screen_point) OVERRIDE {
    188     return false;
    189   }
    190 
    191   virtual bool SaveDetailsLocally() OVERRIDE {
    192     return save_details_locally_checked_;
    193   }
    194 
    195   virtual const content::NavigationController* ShowSignIn() OVERRIDE {
    196     return NULL;
    197   }
    198   virtual void HideSignIn() OVERRIDE {}
    199 
    200   MOCK_METHOD0(ModelChanged, void());
    201   MOCK_METHOD0(UpdateForErrors, void());
    202 
    203   virtual void OnSignInResize(const gfx::Size& pref_size) OVERRIDE {}
    204 
    205   void SetUserInput(DialogSection section, const FieldValueMap& map) {
    206     outputs_[section] = map;
    207   }
    208 
    209   void CheckSaveDetailsLocallyCheckbox(bool checked) {
    210     save_details_locally_checked_ = checked;
    211   }
    212 
    213  private:
    214   std::map<DialogSection, FieldValueMap> outputs_;
    215 
    216   int updates_started_;
    217   bool save_details_locally_checked_;
    218 
    219   DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogView);
    220 };
    221 
    222 class TestAutofillDialogController
    223     : public AutofillDialogControllerImpl,
    224       public base::SupportsWeakPtr<TestAutofillDialogController> {
    225  public:
    226   TestAutofillDialogController(
    227       content::WebContents* contents,
    228       const FormData& form_structure,
    229       const GURL& source_url,
    230       const AutofillMetrics& metric_logger,
    231       const base::Callback<void(const FormStructure*)>& callback,
    232       MockNewCreditCardBubbleController* mock_new_card_bubble_controller)
    233       : AutofillDialogControllerImpl(contents,
    234                                      form_structure,
    235                                      source_url,
    236                                      callback),
    237         metric_logger_(metric_logger),
    238         mock_wallet_client_(
    239             Profile::FromBrowserContext(contents->GetBrowserContext())->
    240                 GetRequestContext(), this, source_url),
    241         mock_new_card_bubble_controller_(mock_new_card_bubble_controller),
    242         submit_button_delay_count_(0) {}
    243 
    244   virtual ~TestAutofillDialogController() {}
    245 
    246   virtual AutofillDialogView* CreateView() OVERRIDE {
    247     return new testing::NiceMock<TestAutofillDialogView>();
    248   }
    249 
    250   void Init(content::BrowserContext* browser_context) {
    251     test_manager_.Init(
    252         WebDataServiceFactory::GetAutofillWebDataForProfile(
    253             Profile::FromBrowserContext(browser_context),
    254             Profile::EXPLICIT_ACCESS),
    255         user_prefs::UserPrefs::Get(browser_context),
    256         browser_context->IsOffTheRecord());
    257   }
    258 
    259   TestAutofillDialogView* GetView() {
    260     return static_cast<TestAutofillDialogView*>(view());
    261   }
    262 
    263   TestPersonalDataManager* GetTestingManager() {
    264     return &test_manager_;
    265   }
    266 
    267   wallet::MockWalletClient* GetTestingWalletClient() {
    268     return &mock_wallet_client_;
    269   }
    270 
    271   const GURL& open_tab_url() { return open_tab_url_; }
    272 
    273   void SimulateSigninError() {
    274     OnWalletSigninError();
    275   }
    276 
    277   // Skips past the 2 second wait between FinishSubmit and DoFinishSubmit.
    278   void ForceFinishSubmit() {
    279     DoFinishSubmit();
    280   }
    281 
    282   void SimulateSubmitButtonDelayBegin() {
    283     AutofillDialogControllerImpl::SubmitButtonDelayBegin();
    284   }
    285 
    286   void SimulateSubmitButtonDelayEnd() {
    287     AutofillDialogControllerImpl::SubmitButtonDelayEndForTesting();
    288   }
    289 
    290   using AutofillDialogControllerImpl::
    291       ClearLastWalletItemsFetchTimestampForTesting;
    292 
    293   // Returns the number of times that the submit button was delayed.
    294   int get_submit_button_delay_count() const {
    295     return submit_button_delay_count_;
    296   }
    297 
    298   MOCK_METHOD0(LoadRiskFingerprintData, void());
    299   using AutofillDialogControllerImpl::AccountChooserModelForTesting;
    300   using AutofillDialogControllerImpl::OnDidLoadRiskFingerprintData;
    301   using AutofillDialogControllerImpl::IsEditingExistingData;
    302   using AutofillDialogControllerImpl::IsSubmitPausedOn;
    303   using AutofillDialogControllerImpl::NOT_CHECKED;
    304   using AutofillDialogControllerImpl::SignedInState;
    305 
    306  protected:
    307   virtual PersonalDataManager* GetManager() const OVERRIDE {
    308     return const_cast<TestAutofillDialogController*>(this)->
    309         GetTestingManager();
    310   }
    311 
    312   virtual wallet::WalletClient* GetWalletClient() OVERRIDE {
    313     return &mock_wallet_client_;
    314   }
    315 
    316   virtual void OpenTabWithUrl(const GURL& url) OVERRIDE {
    317     open_tab_url_ = url;
    318   }
    319 
    320   virtual void ShowNewCreditCardBubble(
    321       scoped_ptr<CreditCard> new_card,
    322       scoped_ptr<AutofillProfile> billing_profile) OVERRIDE {
    323     mock_new_card_bubble_controller_->Show(new_card.Pass(),
    324                                            billing_profile.Pass());
    325   }
    326 
    327   // AutofillDialogControllerImpl calls this method before showing the dialog
    328   // window.
    329   virtual void SubmitButtonDelayBegin() OVERRIDE {
    330     // Do not delay enabling the submit button in testing.
    331     submit_button_delay_count_++;
    332   }
    333 
    334  private:
    335   // To specify our own metric logger.
    336   virtual const AutofillMetrics& GetMetricLogger() const OVERRIDE {
    337     return metric_logger_;
    338   }
    339 
    340   const AutofillMetrics& metric_logger_;
    341   TestPersonalDataManager test_manager_;
    342   testing::NiceMock<wallet::MockWalletClient> mock_wallet_client_;
    343   GURL open_tab_url_;
    344   MockNewCreditCardBubbleController* mock_new_card_bubble_controller_;
    345 
    346   // The number of times that the submit button was delayed.
    347   int submit_button_delay_count_;
    348 
    349   DISALLOW_COPY_AND_ASSIGN(TestAutofillDialogController);
    350 };
    351 
    352 class AutofillDialogControllerTest : public ChromeRenderViewHostTestHarness {
    353  protected:
    354   AutofillDialogControllerTest(): form_structure_(NULL) {}
    355 
    356   // testing::Test implementation:
    357   virtual void SetUp() OVERRIDE {
    358     ChromeRenderViewHostTestHarness::SetUp();
    359     Reset();
    360   }
    361 
    362   virtual void TearDown() OVERRIDE {
    363     if (controller_)
    364       controller_->ViewClosed();
    365     ChromeRenderViewHostTestHarness::TearDown();
    366   }
    367 
    368   void Reset() {
    369     if (controller_)
    370       controller_->ViewClosed();
    371 
    372     test_generated_bubble_controller_ =
    373         new testing::NiceMock<TestGeneratedCreditCardBubbleController>(
    374             web_contents());
    375     ASSERT_TRUE(test_generated_bubble_controller_->IsInstalled());
    376 
    377     mock_new_card_bubble_controller_.reset(
    378         new MockNewCreditCardBubbleController);
    379 
    380     profile()->GetPrefs()->ClearPref(::prefs::kAutofillDialogSaveData);
    381 
    382     // We have to clear the old local state before creating a new one.
    383     scoped_local_state_.reset();
    384     scoped_local_state_.reset(new ScopedTestingLocalState(
    385         TestingBrowserProcess::GetGlobal()));
    386 
    387     SetUpControllerWithFormData(DefaultFormData());
    388   }
    389 
    390   FormData DefaultFormData() {
    391     FormData form_data;
    392     for (size_t i = 0; i < arraysize(kFieldsFromPage); ++i) {
    393       FormFieldData field;
    394       field.autocomplete_attribute = kFieldsFromPage[i];
    395       form_data.fields.push_back(field);
    396     }
    397     return form_data;
    398   }
    399 
    400   // Creates a new controller for |form_data|.
    401   void ResetControllerWithFormData(const FormData& form_data) {
    402     if (controller_)
    403       controller_->ViewClosed();
    404 
    405     base::Callback<void(const FormStructure*)> callback =
    406         base::Bind(&AutofillDialogControllerTest::FinishedCallback,
    407                    base::Unretained(this));
    408     controller_ = (new testing::NiceMock<TestAutofillDialogController>(
    409         web_contents(),
    410         form_data,
    411         GURL(),
    412         metric_logger_,
    413         callback,
    414         mock_new_card_bubble_controller_.get()))->AsWeakPtr();
    415     controller_->Init(profile());
    416   }
    417 
    418   // Creates a new controller for |form_data| and sets up some initial wallet
    419   // data for it.
    420   void SetUpControllerWithFormData(const FormData& form_data) {
    421     ResetControllerWithFormData(form_data);
    422     controller()->Show();
    423     if (!profile()->GetPrefs()->GetBoolean(
    424             ::prefs::kAutofillDialogPayWithoutWallet)) {
    425       EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
    426       controller()->OnDidFetchWalletCookieValue(std::string());
    427       controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
    428     }
    429   }
    430 
    431   // Fills the inputs in SECTION_CC with data.
    432   void FillCreditCardInputs() {
    433     FieldValueMap cc_outputs;
    434     const DetailInputs& cc_inputs =
    435         controller()->RequestedFieldsForSection(SECTION_CC);
    436     for (size_t i = 0; i < cc_inputs.size(); ++i) {
    437       cc_outputs[cc_inputs[i].type] = cc_inputs[i].type == CREDIT_CARD_NUMBER ?
    438           ASCIIToUTF16(kTestCCNumberVisa) : ASCIIToUTF16("11");
    439     }
    440     controller()->GetView()->SetUserInput(SECTION_CC, cc_outputs);
    441   }
    442 
    443   // Fills the inputs in SECTION_CC_BILLING with valid data.
    444   void FillCCBillingInputs() {
    445     FieldValueMap outputs;
    446     const DetailInputs& inputs =
    447         controller()->RequestedFieldsForSection(SECTION_CC_BILLING);
    448     AutofillProfile full_profile(test::GetVerifiedProfile());
    449     CreditCard full_card(test::GetCreditCard());
    450     for (size_t i = 0; i < inputs.size(); ++i) {
    451       const ServerFieldType type = inputs[i].type;
    452       outputs[type] = full_profile.GetInfo(AutofillType(type), "en-US");
    453 
    454       if (outputs[type].empty())
    455         outputs[type] = full_card.GetInfo(AutofillType(type), "en-US");
    456     }
    457     controller()->GetView()->SetUserInput(SECTION_CC_BILLING, outputs);
    458   }
    459 
    460   // Activates the 'Add new foo' option from the |section|'s suggestions
    461   // dropdown and fills the |section|'s inputs with the data from the
    462   // |data_model|.  If |section| is SECTION_CC, also fills in '123' for the CVC.
    463   void FillInputs(DialogSection section, const AutofillDataModel& data_model) {
    464     // Select the 'Add new foo' option.
    465     ui::MenuModel* model = GetMenuModelForSection(section);
    466     if (model)
    467       model->ActivatedAt(model->GetItemCount() - 2);
    468 
    469     // Fill the inputs.
    470     FieldValueMap outputs;
    471     const DetailInputs& inputs =
    472         controller()->RequestedFieldsForSection(section);
    473     for (size_t i = 0; i < inputs.size(); ++i) {
    474       ServerFieldType type = inputs[i].type;
    475       base::string16 output;
    476       if (type == CREDIT_CARD_VERIFICATION_CODE)
    477         output = ASCIIToUTF16("123");
    478       else
    479         output = data_model.GetInfo(AutofillType(type), "en-US");
    480       outputs[inputs[i].type] = output;
    481     }
    482     controller()->GetView()->SetUserInput(section, outputs);
    483   }
    484 
    485   std::vector<DialogNotification> NotificationsOfType(
    486       DialogNotification::Type type) {
    487     std::vector<DialogNotification> right_type;
    488     const std::vector<DialogNotification>& notifications =
    489         controller()->CurrentNotifications();
    490     for (size_t i = 0; i < notifications.size(); ++i) {
    491       if (notifications[i].type() == type)
    492         right_type.push_back(notifications[i]);
    493     }
    494     return right_type;
    495   }
    496 
    497   void SwitchToAutofill() {
    498     ui::MenuModel* model = controller_->MenuModelForAccountChooser();
    499     model->ActivatedAt(model->GetItemCount() - 1);
    500   }
    501 
    502   void SwitchToWallet() {
    503     controller_->MenuModelForAccountChooser()->ActivatedAt(0);
    504   }
    505 
    506   void SimulateSigninError() {
    507     controller_->SimulateSigninError();
    508   }
    509 
    510   void UseBillingForShipping() {
    511     controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(0);
    512   }
    513 
    514   void ValidateCCNumber(DialogSection section,
    515                         const std::string& cc_number,
    516                         bool should_pass) {
    517     FieldValueMap outputs;
    518     outputs[CREDIT_CARD_NUMBER] = UTF8ToUTF16(cc_number);
    519     ValidityMessages messages =
    520         controller()->InputsAreValid(section, outputs);
    521     EXPECT_EQ(should_pass, !messages.HasSureError(CREDIT_CARD_NUMBER));
    522   }
    523 
    524   void SubmitWithWalletItems(scoped_ptr<wallet::WalletItems> wallet_items) {
    525     controller()->OnDidGetWalletItems(wallet_items.Pass());
    526     AcceptAndLoadFakeFingerprint();
    527   }
    528 
    529   void AcceptAndLoadFakeFingerprint() {
    530     controller()->OnAccept();
    531     controller()->OnDidLoadRiskFingerprintData(GetFakeFingerprint().Pass());
    532   }
    533 
    534   // Returns true if the given |section| contains a field of the given |type|.
    535   bool SectionContainsField(DialogSection section, ServerFieldType type) {
    536     const DetailInputs& inputs =
    537         controller()->RequestedFieldsForSection(section);
    538     for (DetailInputs::const_iterator it = inputs.begin(); it != inputs.end();
    539          ++it) {
    540       if (it->type == type)
    541         return true;
    542     }
    543     return false;
    544   }
    545 
    546   SuggestionsMenuModel* GetMenuModelForSection(DialogSection section) {
    547     ui::MenuModel* model = controller()->MenuModelForSection(section);
    548     return static_cast<SuggestionsMenuModel*>(model);
    549   }
    550 
    551   TestAutofillDialogController* controller() { return controller_.get(); }
    552 
    553   const FormStructure* form_structure() { return form_structure_; }
    554 
    555   TestGeneratedCreditCardBubbleController* test_generated_bubble_controller() {
    556     return test_generated_bubble_controller_;
    557   }
    558 
    559   const MockNewCreditCardBubbleController* mock_new_card_bubble_controller() {
    560     return mock_new_card_bubble_controller_.get();
    561   }
    562 
    563  private:
    564   void FinishedCallback(const FormStructure* form_structure) {
    565     form_structure_ = form_structure;
    566   }
    567 
    568 #if defined(OS_WIN)
    569    // http://crbug.com/227221
    570    ui::ScopedOleInitializer ole_initializer_;
    571 #endif
    572 
    573   // The controller owns itself.
    574   base::WeakPtr<TestAutofillDialogController> controller_;
    575 
    576   // Must outlive the controller.
    577   AutofillMetrics metric_logger_;
    578 
    579   // Returned when the dialog closes successfully.
    580   const FormStructure* form_structure_;
    581 
    582   // Used to monitor if the Autofill credit card bubble is shown. Owned by
    583   // |web_contents()|.
    584   TestGeneratedCreditCardBubbleController* test_generated_bubble_controller_;
    585 
    586   // Used to record when new card bubbles would show. Created in |Reset()|.
    587   scoped_ptr<MockNewCreditCardBubbleController>
    588       mock_new_card_bubble_controller_;
    589 
    590   scoped_ptr<ScopedTestingLocalState> scoped_local_state_;
    591 };
    592 
    593 }  // namespace
    594 
    595 // Ensure the default ValidityMessage has the expected values.
    596 TEST_F(AutofillDialogControllerTest, DefaultValidityMessage) {
    597   ValidityMessages messages;
    598   ValidityMessage message = messages.GetMessageOrDefault(UNKNOWN_TYPE);
    599   EXPECT_FALSE(message.sure);
    600   EXPECT_TRUE(message.text.empty());
    601 }
    602 
    603 // This test makes sure nothing falls over when fields are being validity-
    604 // checked.
    605 TEST_F(AutofillDialogControllerTest, ValidityCheck) {
    606   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
    607     DialogSection section = static_cast<DialogSection>(i);
    608     const DetailInputs& shipping_inputs =
    609         controller()->RequestedFieldsForSection(section);
    610     for (DetailInputs::const_iterator iter = shipping_inputs.begin();
    611          iter != shipping_inputs.end(); ++iter) {
    612       controller()->InputValidityMessage(section, iter->type, base::string16());
    613     }
    614   }
    615 }
    616 
    617 // Test for phone number validation.
    618 TEST_F(AutofillDialogControllerTest, PhoneNumberValidation) {
    619   // Construct FieldValueMap from existing data.
    620   SwitchToAutofill();
    621 
    622   for (size_t i = 0; i < 2; ++i) {
    623     ServerFieldType phone = i == 0 ? PHONE_HOME_WHOLE_NUMBER :
    624                                      PHONE_BILLING_WHOLE_NUMBER;
    625     ServerFieldType address = i == 0 ? ADDRESS_HOME_COUNTRY :
    626                                        ADDRESS_BILLING_COUNTRY;
    627     DialogSection section = i == 0 ? SECTION_SHIPPING : SECTION_BILLING;
    628 
    629     FieldValueMap outputs;
    630     const DetailInputs& inputs =
    631         controller()->RequestedFieldsForSection(section);
    632     AutofillProfile full_profile(test::GetVerifiedProfile());
    633     for (size_t i = 0; i < inputs.size(); ++i) {
    634       const ServerFieldType type = inputs[i].type;
    635       outputs[type] = full_profile.GetInfo(AutofillType(type), "en-US");
    636     }
    637 
    638     // Make sure country is United States.
    639     outputs[address] = ASCIIToUTF16("United States");
    640 
    641     // Existing data should have no errors.
    642     ValidityMessages messages = controller()->InputsAreValid(section, outputs);
    643     EXPECT_FALSE(HasAnyError(messages, phone));
    644 
    645     // Input an empty phone number.
    646     outputs[phone] = base::string16();
    647     messages = controller()->InputsAreValid(section, outputs);
    648     EXPECT_TRUE(HasUnsureError(messages, phone));
    649 
    650     // Input an invalid phone number.
    651     outputs[phone] = ASCIIToUTF16("ABC");
    652     messages = controller()->InputsAreValid(section, outputs);
    653     EXPECT_TRUE(messages.HasSureError(phone));
    654 
    655     // Input a local phone number.
    656     outputs[phone] = ASCIIToUTF16("2155546699");
    657     messages = controller()->InputsAreValid(section, outputs);
    658     EXPECT_FALSE(HasAnyError(messages, phone));
    659 
    660     // Input an invalid local phone number.
    661     outputs[phone] = ASCIIToUTF16("215554669");
    662     messages = controller()->InputsAreValid(section, outputs);
    663     EXPECT_TRUE(messages.HasSureError(phone));
    664 
    665     // Input an international phone number.
    666     outputs[phone] = ASCIIToUTF16("+33 892 70 12 39");
    667     messages = controller()->InputsAreValid(section, outputs);
    668     EXPECT_FALSE(HasAnyError(messages, phone));
    669 
    670     // Input an invalid international phone number.
    671     outputs[phone] = ASCIIToUTF16("+112333 892 70 12 39");
    672     messages = controller()->InputsAreValid(section, outputs);
    673     EXPECT_TRUE(messages.HasSureError(phone));
    674   }
    675 }
    676 
    677 TEST_F(AutofillDialogControllerTest, ExpirationDateValidity) {
    678   ui::ComboboxModel* exp_year_model =
    679       controller()->ComboboxModelForAutofillType(CREDIT_CARD_EXP_4_DIGIT_YEAR);
    680   ui::ComboboxModel* exp_month_model =
    681       controller()->ComboboxModelForAutofillType(CREDIT_CARD_EXP_MONTH);
    682 
    683   base::string16 default_year_value =
    684       exp_year_model->GetItemAt(exp_year_model->GetDefaultIndex());
    685   base::string16 default_month_value =
    686       exp_month_model->GetItemAt(exp_month_model->GetDefaultIndex());
    687 
    688   base::string16 other_year_value =
    689       exp_year_model->GetItemAt(exp_year_model->GetItemCount() - 1);
    690   base::string16 other_month_value =
    691       exp_month_model->GetItemAt(exp_month_model->GetItemCount() - 1);
    692 
    693   FieldValueMap outputs;
    694   outputs[CREDIT_CARD_EXP_MONTH] = default_month_value;
    695   outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = default_year_value;
    696 
    697   // Expiration default values generate unsure validation errors (but not sure).
    698   ValidityMessages messages = controller()->InputsAreValid(SECTION_CC_BILLING,
    699                                                            outputs);
    700   EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR));
    701   EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH));
    702 
    703   // Expiration date with default month fails.
    704   outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = other_year_value;
    705   messages = controller()->InputsAreValid(SECTION_CC_BILLING, outputs);
    706   EXPECT_FALSE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR));
    707   EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH));
    708 
    709   // Expiration date with default year fails.
    710   outputs[CREDIT_CARD_EXP_MONTH] = other_month_value;
    711   outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = default_year_value;
    712   messages = controller()->InputsAreValid(SECTION_CC_BILLING, outputs);
    713   EXPECT_TRUE(HasUnsureError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR));
    714   EXPECT_FALSE(HasUnsureError(messages, CREDIT_CARD_EXP_MONTH));
    715 }
    716 
    717 TEST_F(AutofillDialogControllerTest, BillingNameValidation) {
    718   // Construct FieldValueMap from AutofillProfile data.
    719   SwitchToAutofill();
    720 
    721   // Input an empty billing name.
    722   FieldValueMap outputs;
    723   outputs[NAME_BILLING_FULL] = base::string16();
    724   ValidityMessages messages = controller()->InputsAreValid(SECTION_BILLING,
    725                                                            outputs);
    726   EXPECT_TRUE(HasUnsureError(messages, NAME_BILLING_FULL));
    727 
    728   // Input a non-empty billing name.
    729   outputs[NAME_BILLING_FULL] = ASCIIToUTF16("Bob");
    730   messages = controller()->InputsAreValid(SECTION_BILLING, outputs);
    731   EXPECT_FALSE(HasAnyError(messages, NAME_BILLING_FULL));
    732 
    733   // Switch to Wallet which only considers names with with at least two names to
    734   // be valid.
    735   SwitchToWallet();
    736 
    737   // Setup some wallet state.
    738   scoped_ptr<wallet::WalletItems> wallet_items =
    739       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
    740   controller()->OnDidGetWalletItems(wallet_items.Pass());
    741 
    742   // Input an empty billing name. Data source should not change this behavior.
    743   FieldValueMap wallet_outputs;
    744   wallet_outputs[NAME_BILLING_FULL] = base::string16();
    745   messages = controller()->InputsAreValid(SECTION_CC_BILLING, wallet_outputs);
    746   EXPECT_TRUE(HasUnsureError(messages, NAME_BILLING_FULL));
    747 
    748   // Input a one name billing name. Wallet does not currently support this.
    749   wallet_outputs[NAME_BILLING_FULL] = ASCIIToUTF16("Bob");
    750   messages = controller()->InputsAreValid(SECTION_CC_BILLING, wallet_outputs);
    751   EXPECT_TRUE(messages.HasSureError(NAME_BILLING_FULL));
    752 
    753   // Input a two name billing name.
    754   wallet_outputs[NAME_BILLING_FULL] = ASCIIToUTF16("Bob Barker");
    755   messages = controller()->InputsAreValid(SECTION_CC_BILLING, wallet_outputs);
    756   EXPECT_FALSE(HasAnyError(messages, NAME_BILLING_FULL));
    757 
    758   // Input a more than two name billing name.
    759   wallet_outputs[NAME_BILLING_FULL] =
    760       ASCIIToUTF16("John Jacob Jingleheimer Schmidt"),
    761   messages = controller()->InputsAreValid(SECTION_CC_BILLING, wallet_outputs);
    762   EXPECT_FALSE(HasAnyError(messages, NAME_BILLING_FULL));
    763 
    764   // Input a billing name with lots of crazy whitespace.
    765   wallet_outputs[NAME_BILLING_FULL] =
    766       ASCIIToUTF16("     \\n\\r John \\n  Jacob Jingleheimer \\t Schmidt  "),
    767   messages = controller()->InputsAreValid(SECTION_CC_BILLING, wallet_outputs);
    768   EXPECT_FALSE(HasAnyError(messages, NAME_BILLING_FULL));
    769 }
    770 
    771 TEST_F(AutofillDialogControllerTest, CreditCardNumberValidation) {
    772   // Construct FieldValueMap from AutofillProfile data.
    773   SwitchToAutofill();
    774 
    775   // Should accept AMEX, Visa, Master and Discover.
    776   ValidateCCNumber(SECTION_CC, kTestCCNumberVisa, true);
    777   ValidateCCNumber(SECTION_CC, kTestCCNumberMaster, true);
    778   ValidateCCNumber(SECTION_CC, kTestCCNumberDiscover, true);
    779   ValidateCCNumber(SECTION_CC, kTestCCNumberAmex, true);
    780   ValidateCCNumber(SECTION_CC, kTestCCNumberIncomplete, false);
    781   ValidateCCNumber(SECTION_CC, kTestCCNumberInvalid, false);
    782 
    783   // Switch to Wallet which will not accept AMEX.
    784   SwitchToWallet();
    785 
    786   // Setup some wallet state on a merchant for which Wallet doesn't
    787   // support AMEX.
    788   controller()->OnDidGetWalletItems(
    789       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED));
    790 
    791   // Should accept Visa, Master and Discover, but not AMEX.
    792   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberVisa, true);
    793   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberMaster, true);
    794   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberDiscover, true);
    795   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberAmex, false);
    796   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberIncomplete, false);
    797   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberInvalid, false);
    798 
    799   // Setup some wallet state on a merchant for which Wallet supports AMEX.
    800   controller()->OnDidGetWalletItems(
    801       wallet::GetTestWalletItems(wallet::AMEX_ALLOWED));
    802 
    803   // Should accept Visa, Master, Discover, and AMEX.
    804   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberVisa, true);
    805   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberMaster, true);
    806   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberDiscover, true);
    807   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberAmex, true);
    808   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberIncomplete, false);
    809   ValidateCCNumber(SECTION_CC_BILLING, kTestCCNumberInvalid, false);
    810 }
    811 
    812 TEST_F(AutofillDialogControllerTest, AutofillProfiles) {
    813   SwitchToAutofill();
    814   ui::MenuModel* shipping_model =
    815       controller()->MenuModelForSection(SECTION_SHIPPING);
    816   // Since the PersonalDataManager is empty, this should only have the
    817   // "use billing", "add new" and "manage" menu items.
    818   ASSERT_TRUE(shipping_model);
    819   EXPECT_EQ(3, shipping_model->GetItemCount());
    820   // On the other hand, the other models should be NULL when there's no
    821   // suggestion.
    822   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC));
    823   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_BILLING));
    824 
    825   EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(3);
    826 
    827   // Empty profiles are ignored.
    828   AutofillProfile empty_profile(base::GenerateGUID(), kSettingsOrigin);
    829   empty_profile.SetRawInfo(NAME_FULL, ASCIIToUTF16("John Doe"));
    830   controller()->GetTestingManager()->AddTestingProfile(&empty_profile);
    831   shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING);
    832   ASSERT_TRUE(shipping_model);
    833   EXPECT_EQ(3, shipping_model->GetItemCount());
    834 
    835   // An otherwise full but unverified profile should be ignored.
    836   AutofillProfile full_profile(test::GetFullProfile());
    837   full_profile.set_origin("https://www.example.com");
    838   full_profile.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
    839   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
    840   shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING);
    841   ASSERT_TRUE(shipping_model);
    842   EXPECT_EQ(3, shipping_model->GetItemCount());
    843 
    844   // A full, verified profile should be picked up.
    845   AutofillProfile verified_profile(test::GetVerifiedProfile());
    846   verified_profile.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
    847   controller()->GetTestingManager()->AddTestingProfile(&verified_profile);
    848   shipping_model = controller()->MenuModelForSection(SECTION_SHIPPING);
    849   ASSERT_TRUE(shipping_model);
    850   EXPECT_EQ(4, shipping_model->GetItemCount());
    851 }
    852 
    853 // Makes sure that the choice of which Autofill profile to use for each section
    854 // is sticky.
    855 TEST_F(AutofillDialogControllerTest, AutofillProfileDefaults) {
    856   SwitchToAutofill();
    857   AutofillProfile profile(test::GetVerifiedProfile());
    858   AutofillProfile profile2(test::GetVerifiedProfile2());
    859   controller()->GetTestingManager()->AddTestingProfile(&profile);
    860   controller()->GetTestingManager()->AddTestingProfile(&profile2);
    861 
    862   // Until a selection has been made, the default shipping suggestion is the
    863   // first one (after "use billing").
    864   SuggestionsMenuModel* shipping_model =
    865       GetMenuModelForSection(SECTION_SHIPPING);
    866   EXPECT_EQ(1, shipping_model->checked_item());
    867 
    868   for (int i = 2; i >= 0; --i) {
    869     shipping_model = GetMenuModelForSection(SECTION_SHIPPING);
    870     shipping_model->ExecuteCommand(i, 0);
    871     FillCreditCardInputs();
    872     controller()->OnAccept();
    873 
    874     Reset();
    875     controller()->GetTestingManager()->AddTestingProfile(&profile);
    876     controller()->GetTestingManager()->AddTestingProfile(&profile2);
    877     shipping_model = GetMenuModelForSection(SECTION_SHIPPING);
    878     EXPECT_EQ(i, shipping_model->checked_item());
    879   }
    880 
    881   // Try again, but don't add the default profile to the PDM. The dialog
    882   // should fall back to the first profile.
    883   shipping_model->ExecuteCommand(2, 0);
    884   FillCreditCardInputs();
    885   controller()->OnAccept();
    886   Reset();
    887   controller()->GetTestingManager()->AddTestingProfile(&profile);
    888   shipping_model = GetMenuModelForSection(SECTION_SHIPPING);
    889   EXPECT_EQ(1, shipping_model->checked_item());
    890 }
    891 
    892 // Makes sure that a newly added Autofill profile becomes set as the default
    893 // choice for the next run.
    894 TEST_F(AutofillDialogControllerTest, NewAutofillProfileIsDefault) {
    895   SwitchToAutofill();
    896 
    897   AutofillProfile profile(test::GetVerifiedProfile());
    898   CreditCard credit_card(test::GetVerifiedCreditCard());
    899   controller()->GetTestingManager()->AddTestingProfile(&profile);
    900   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
    901 
    902   // Until a selection has been made, the default suggestion is the first one.
    903   // For the shipping section, this follows the "use billing" suggestion.
    904   EXPECT_EQ(0, GetMenuModelForSection(SECTION_CC)->checked_item());
    905   EXPECT_EQ(1, GetMenuModelForSection(SECTION_SHIPPING)->checked_item());
    906 
    907   // Fill in the shipping and credit card sections with new data.
    908   AutofillProfile new_profile(test::GetVerifiedProfile2());
    909   CreditCard new_credit_card(test::GetVerifiedCreditCard2());
    910   FillInputs(SECTION_SHIPPING, new_profile);
    911   FillInputs(SECTION_CC, new_credit_card);
    912   controller()->GetView()->CheckSaveDetailsLocallyCheckbox(true);
    913   controller()->OnAccept();
    914 
    915   // Update the |new_profile| and |new_credit_card|'s guids to the saved ones.
    916   new_profile.set_guid(
    917       controller()->GetTestingManager()->imported_profile().guid());
    918   new_credit_card.set_guid(
    919       controller()->GetTestingManager()->imported_credit_card().guid());
    920 
    921   // Reload the dialog. The newly added address and credit card should now be
    922   // set as the defaults.
    923   Reset();
    924   controller()->GetTestingManager()->AddTestingProfile(&profile);
    925   controller()->GetTestingManager()->AddTestingProfile(&new_profile);
    926   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
    927   controller()->GetTestingManager()->AddTestingCreditCard(&new_credit_card);
    928 
    929   // Until a selection has been made, the default suggestion is the first one.
    930   // For the shipping section, this follows the "use billing" suggestion.
    931   EXPECT_EQ(1, GetMenuModelForSection(SECTION_CC)->checked_item());
    932   EXPECT_EQ(2, GetMenuModelForSection(SECTION_SHIPPING)->checked_item());
    933 }
    934 
    935 TEST_F(AutofillDialogControllerTest, AutofillProfileVariants) {
    936   SwitchToAutofill();
    937   EXPECT_CALL(*controller()->GetView(), ModelChanged());
    938   ui::MenuModel* shipping_model =
    939       controller()->MenuModelForSection(SECTION_SHIPPING);
    940   ASSERT_TRUE(!!shipping_model);
    941   EXPECT_EQ(3, shipping_model->GetItemCount());
    942 
    943   // Set up some variant data.
    944   AutofillProfile full_profile(test::GetVerifiedProfile());
    945   std::vector<base::string16> names;
    946   names.push_back(ASCIIToUTF16("John Doe"));
    947   names.push_back(ASCIIToUTF16("Jane Doe"));
    948   full_profile.SetRawMultiInfo(NAME_FULL, names);
    949   std::vector<base::string16> emails;
    950   emails.push_back(ASCIIToUTF16(kFakeEmail));
    951   emails.push_back(ASCIIToUTF16("admin (at) example.com"));
    952   full_profile.SetRawMultiInfo(EMAIL_ADDRESS, emails);
    953 
    954   // Non-default variants are ignored by the dialog.
    955   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
    956   EXPECT_EQ(4, shipping_model->GetItemCount());
    957 }
    958 
    959 TEST_F(AutofillDialogControllerTest, SuggestValidEmail) {
    960   SwitchToAutofill();
    961   AutofillProfile profile(test::GetVerifiedProfile());
    962   const base::string16 kValidEmail = ASCIIToUTF16(kFakeEmail);
    963   profile.SetRawInfo(EMAIL_ADDRESS, kValidEmail);
    964   controller()->GetTestingManager()->AddTestingProfile(&profile);
    965 
    966   // "add", "manage", and 1 suggestion.
    967   EXPECT_EQ(
    968       3, controller()->MenuModelForSection(SECTION_BILLING)->GetItemCount());
    969   // "add", "manage", 1 suggestion, and "same as billing".
    970   EXPECT_EQ(
    971       4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
    972 }
    973 
    974 TEST_F(AutofillDialogControllerTest, DoNotSuggestInvalidEmail) {
    975   SwitchToAutofill();
    976   AutofillProfile profile(test::GetVerifiedProfile());
    977   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16(".!#$%&'*+/=?^_`- (at) -.."));
    978   controller()->GetTestingManager()->AddTestingProfile(&profile);
    979 
    980   EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING));
    981   // "add", "manage", 1 suggestion, and "same as billing".
    982   EXPECT_EQ(
    983       4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
    984 }
    985 
    986 TEST_F(AutofillDialogControllerTest, SuggestValidAddress) {
    987   SwitchToAutofill();
    988   AutofillProfile full_profile(test::GetVerifiedProfile());
    989   full_profile.set_origin(kSettingsOrigin);
    990   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
    991   // "add", "manage", and 1 suggestion.
    992   EXPECT_EQ(
    993       3, controller()->MenuModelForSection(SECTION_BILLING)->GetItemCount());
    994 }
    995 
    996 TEST_F(AutofillDialogControllerTest, DoNotSuggestInvalidAddress) {
    997   SwitchToAutofill();
    998   AutofillProfile full_profile(test::GetVerifiedProfile());
    999   full_profile.set_origin(kSettingsOrigin);
   1000   full_profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("C"));
   1001   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1002 
   1003   EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING));
   1004 }
   1005 
   1006 TEST_F(AutofillDialogControllerTest, DoNotSuggestIncompleteAddress) {
   1007   SwitchToAutofill();
   1008   AutofillProfile profile(test::GetVerifiedProfile());
   1009   profile.SetRawInfo(ADDRESS_HOME_STATE, base::string16());
   1010   controller()->GetTestingManager()->AddTestingProfile(&profile);
   1011 
   1012   EXPECT_FALSE(!!controller()->MenuModelForSection(SECTION_BILLING));
   1013 }
   1014 
   1015 TEST_F(AutofillDialogControllerTest, AutofillCreditCards) {
   1016   SwitchToAutofill();
   1017   // Since the PersonalDataManager is empty, this should only have the
   1018   // default menu items.
   1019   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC));
   1020 
   1021   EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(3);
   1022 
   1023   // Empty cards are ignored.
   1024   CreditCard empty_card(base::GenerateGUID(), kSettingsOrigin);
   1025   empty_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("John Doe"));
   1026   controller()->GetTestingManager()->AddTestingCreditCard(&empty_card);
   1027   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC));
   1028 
   1029   // An otherwise full but unverified card should be ignored.
   1030   CreditCard full_card(test::GetCreditCard());
   1031   full_card.set_origin("https://www.example.com");
   1032   controller()->GetTestingManager()->AddTestingCreditCard(&full_card);
   1033   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC));
   1034 
   1035   // A full, verified card should be picked up.
   1036   CreditCard verified_card(test::GetCreditCard());
   1037   verified_card.set_origin(kSettingsOrigin);
   1038   controller()->GetTestingManager()->AddTestingCreditCard(&verified_card);
   1039   ui::MenuModel* credit_card_model =
   1040       controller()->MenuModelForSection(SECTION_CC);
   1041   ASSERT_TRUE(credit_card_model);
   1042   EXPECT_EQ(3, credit_card_model->GetItemCount());
   1043 }
   1044 
   1045 // Test selecting a shipping address different from billing as address.
   1046 TEST_F(AutofillDialogControllerTest, DontUseBillingAsShipping) {
   1047   SwitchToAutofill();
   1048   AutofillProfile full_profile(test::GetVerifiedProfile());
   1049   AutofillProfile full_profile2(test::GetVerifiedProfile2());
   1050   CreditCard credit_card(test::GetVerifiedCreditCard());
   1051   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1052   controller()->GetTestingManager()->AddTestingProfile(&full_profile2);
   1053   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
   1054   ui::MenuModel* shipping_model =
   1055       controller()->MenuModelForSection(SECTION_SHIPPING);
   1056   shipping_model->ActivatedAt(2);
   1057 
   1058   controller()->OnAccept();
   1059   ASSERT_EQ(20U, form_structure()->field_count());
   1060   EXPECT_EQ(ADDRESS_HOME_STATE,
   1061             form_structure()->field(9)->Type().GetStorableType());
   1062   EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(9)->Type().group());
   1063   EXPECT_EQ(ADDRESS_HOME_STATE,
   1064             form_structure()->field(16)->Type().GetStorableType());
   1065   EXPECT_EQ(ADDRESS_HOME, form_structure()->field(16)->Type().group());
   1066   base::string16 billing_state = form_structure()->field(9)->value;
   1067   base::string16 shipping_state = form_structure()->field(16)->value;
   1068   EXPECT_FALSE(billing_state.empty());
   1069   EXPECT_FALSE(shipping_state.empty());
   1070   EXPECT_NE(billing_state, shipping_state);
   1071 
   1072   EXPECT_EQ(CREDIT_CARD_NAME,
   1073             form_structure()->field(1)->Type().GetStorableType());
   1074   base::string16 cc_name = form_structure()->field(1)->value;
   1075   EXPECT_EQ(NAME_FULL, form_structure()->field(6)->Type().GetStorableType());
   1076   EXPECT_EQ(NAME_BILLING, form_structure()->field(6)->Type().group());
   1077   base::string16 billing_name = form_structure()->field(6)->value;
   1078   EXPECT_EQ(NAME_FULL, form_structure()->field(13)->Type().GetStorableType());
   1079   EXPECT_EQ(NAME, form_structure()->field(13)->Type().group());
   1080   base::string16 shipping_name = form_structure()->field(13)->value;
   1081 
   1082   EXPECT_FALSE(cc_name.empty());
   1083   EXPECT_FALSE(billing_name.empty());
   1084   EXPECT_FALSE(shipping_name.empty());
   1085   // Billing name should always be the same as cardholder name.
   1086   EXPECT_EQ(cc_name, billing_name);
   1087   EXPECT_NE(cc_name, shipping_name);
   1088 }
   1089 
   1090 // Test selecting UseBillingForShipping.
   1091 TEST_F(AutofillDialogControllerTest, UseBillingAsShipping) {
   1092   SwitchToAutofill();
   1093   AutofillProfile full_profile(test::GetVerifiedProfile());
   1094   AutofillProfile full_profile2(test::GetVerifiedProfile2());
   1095   CreditCard credit_card(test::GetVerifiedCreditCard());
   1096   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1097   controller()->GetTestingManager()->AddTestingProfile(&full_profile2);
   1098   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
   1099 
   1100   // Test after setting use billing for shipping.
   1101   UseBillingForShipping();
   1102 
   1103   controller()->OnAccept();
   1104   ASSERT_EQ(20U, form_structure()->field_count());
   1105   EXPECT_EQ(ADDRESS_HOME_STATE,
   1106             form_structure()->field(9)->Type().GetStorableType());
   1107   EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(9)->Type().group());
   1108   EXPECT_EQ(ADDRESS_HOME_STATE,
   1109             form_structure()->field(16)->Type().GetStorableType());
   1110   EXPECT_EQ(ADDRESS_HOME, form_structure()->field(16)->Type().group());
   1111   base::string16 billing_state = form_structure()->field(9)->value;
   1112   base::string16 shipping_state = form_structure()->field(16)->value;
   1113   EXPECT_FALSE(billing_state.empty());
   1114   EXPECT_FALSE(shipping_state.empty());
   1115   EXPECT_EQ(billing_state, shipping_state);
   1116 
   1117   EXPECT_EQ(CREDIT_CARD_NAME,
   1118             form_structure()->field(1)->Type().GetStorableType());
   1119   base::string16 cc_name = form_structure()->field(1)->value;
   1120   EXPECT_EQ(NAME_FULL, form_structure()->field(6)->Type().GetStorableType());
   1121   EXPECT_EQ(NAME_BILLING, form_structure()->field(6)->Type().group());
   1122   base::string16 billing_name = form_structure()->field(6)->value;
   1123   EXPECT_EQ(NAME_FULL, form_structure()->field(13)->Type().GetStorableType());
   1124   EXPECT_EQ(NAME, form_structure()->field(13)->Type().group());
   1125   base::string16 shipping_name = form_structure()->field(13)->value;
   1126 
   1127   EXPECT_FALSE(cc_name.empty());
   1128   EXPECT_FALSE(billing_name.empty());
   1129   EXPECT_FALSE(shipping_name.empty());
   1130   EXPECT_EQ(cc_name, billing_name);
   1131   EXPECT_EQ(cc_name, shipping_name);
   1132 }
   1133 
   1134 // Tests that shipping and billing telephone fields are supported, and filled
   1135 // in by their respective profiles. http://crbug.com/244515
   1136 TEST_F(AutofillDialogControllerTest, BillingVsShippingPhoneNumber) {
   1137   FormFieldData shipping_tel;
   1138   shipping_tel.autocomplete_attribute = "shipping tel";
   1139   FormFieldData billing_tel;
   1140   billing_tel.autocomplete_attribute = "billing tel";
   1141 
   1142   FormData form_data;
   1143   form_data.fields.push_back(shipping_tel);
   1144   form_data.fields.push_back(billing_tel);
   1145   SetUpControllerWithFormData(form_data);
   1146 
   1147   SwitchToAutofill();
   1148 
   1149   // The profile that will be chosen for the shipping section.
   1150   AutofillProfile shipping_profile(test::GetVerifiedProfile());
   1151   // The profile that will be chosen for the billing section.
   1152   AutofillProfile billing_profile(test::GetVerifiedProfile2());
   1153   CreditCard credit_card(test::GetVerifiedCreditCard());
   1154   controller()->GetTestingManager()->AddTestingProfile(&shipping_profile);
   1155   controller()->GetTestingManager()->AddTestingProfile(&billing_profile);
   1156   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
   1157   ui::MenuModel* billing_model =
   1158       controller()->MenuModelForSection(SECTION_BILLING);
   1159   billing_model->ActivatedAt(1);
   1160 
   1161   controller()->OnAccept();
   1162   ASSERT_EQ(2U, form_structure()->field_count());
   1163   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
   1164             form_structure()->field(0)->Type().GetStorableType());
   1165   EXPECT_EQ(PHONE_HOME, form_structure()->field(0)->Type().group());
   1166   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
   1167             form_structure()->field(1)->Type().GetStorableType());
   1168   EXPECT_EQ(PHONE_BILLING, form_structure()->field(1)->Type().group());
   1169   EXPECT_EQ(shipping_profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER),
   1170             form_structure()->field(0)->value);
   1171   EXPECT_EQ(billing_profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER),
   1172             form_structure()->field(1)->value);
   1173   EXPECT_NE(form_structure()->field(1)->value,
   1174             form_structure()->field(0)->value);
   1175 }
   1176 
   1177 TEST_F(AutofillDialogControllerTest, AcceptLegalDocuments) {
   1178   for (size_t i = 0; i < 2; ++i) {
   1179     SCOPED_TRACE(testing::Message() << "Case " << i);
   1180 
   1181     EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1182                 AcceptLegalDocuments(_, _));
   1183     EXPECT_CALL(*controller()->GetTestingWalletClient(), GetFullWallet(_));
   1184     EXPECT_CALL(*controller(), LoadRiskFingerprintData());
   1185 
   1186     EXPECT_TRUE(controller()->LegalDocumentLinks().empty());
   1187     controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1188     EXPECT_TRUE(controller()->LegalDocumentLinks().empty());
   1189 
   1190     scoped_ptr<wallet::WalletItems> wallet_items =
   1191         CompleteAndValidWalletItems();
   1192     wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   1193     wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   1194     controller()->OnDidGetWalletItems(wallet_items.Pass());
   1195     EXPECT_FALSE(controller()->LegalDocumentLinks().empty());
   1196 
   1197     controller()->OnAccept();
   1198     controller()->OnDidAcceptLegalDocuments();
   1199     controller()->OnDidLoadRiskFingerprintData(GetFakeFingerprint().Pass());
   1200 
   1201     // Now try it all over again with the location disclosure already accepted.
   1202     // Nothing should change.
   1203     Reset();
   1204     ListValue preexisting_list;
   1205     preexisting_list.AppendString(kFakeEmail);
   1206     g_browser_process->local_state()->Set(
   1207         ::prefs::kAutofillDialogWalletLocationAcceptance,
   1208         preexisting_list);
   1209   }
   1210 }
   1211 
   1212 TEST_F(AutofillDialogControllerTest, RejectLegalDocuments) {
   1213   for (size_t i = 0; i < 2; ++i) {
   1214     SCOPED_TRACE(testing::Message() << "Case " << i);
   1215 
   1216     EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1217                 AcceptLegalDocuments(_, _)).Times(0);
   1218 
   1219     scoped_ptr<wallet::WalletItems> wallet_items =
   1220         CompleteAndValidWalletItems();
   1221     wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   1222     wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   1223     controller()->OnDidGetWalletItems(wallet_items.Pass());
   1224     EXPECT_FALSE(controller()->LegalDocumentLinks().empty());
   1225 
   1226     controller()->OnCancel();
   1227 
   1228     // Now try it all over again with the location disclosure already accepted.
   1229     // Nothing should change.
   1230     Reset();
   1231     ListValue preexisting_list;
   1232     preexisting_list.AppendString(kFakeEmail);
   1233     g_browser_process->local_state()->Set(
   1234         ::prefs::kAutofillDialogWalletLocationAcceptance,
   1235         preexisting_list);
   1236   }
   1237 }
   1238 
   1239 TEST_F(AutofillDialogControllerTest, AcceptLocationDisclosure) {
   1240   // Check that accepting the dialog registers the user's name in the list
   1241   // of users who have accepted the geolocation terms.
   1242   EXPECT_TRUE(g_browser_process->local_state()->GetList(
   1243       ::prefs::kAutofillDialogWalletLocationAcceptance)->empty());
   1244 
   1245   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1246   EXPECT_FALSE(controller()->LegalDocumentsText().empty());
   1247   EXPECT_TRUE(controller()->LegalDocumentLinks().empty());
   1248   controller()->OnAccept();
   1249 
   1250   const ListValue* list = g_browser_process->local_state()->GetList(
   1251       ::prefs::kAutofillDialogWalletLocationAcceptance);
   1252   ASSERT_EQ(1U, list->GetSize());
   1253   std::string accepted_username;
   1254   EXPECT_TRUE(list->GetString(0, &accepted_username));
   1255   EXPECT_EQ(kFakeEmail, accepted_username);
   1256 
   1257   // Now check it still works if that list starts off with some other username
   1258   // in it.
   1259   Reset();
   1260   list = g_browser_process->local_state()->GetList(
   1261       ::prefs::kAutofillDialogWalletLocationAcceptance);
   1262   ASSERT_TRUE(list->empty());
   1263 
   1264   std::string kOtherUsername("spouse (at) example.com");
   1265   ListValue preexisting_list;
   1266   preexisting_list.AppendString(kOtherUsername);
   1267   g_browser_process->local_state()->Set(
   1268       ::prefs::kAutofillDialogWalletLocationAcceptance,
   1269       preexisting_list);
   1270 
   1271   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1272   EXPECT_FALSE(controller()->LegalDocumentsText().empty());
   1273   EXPECT_TRUE(controller()->LegalDocumentLinks().empty());
   1274   controller()->OnAccept();
   1275 
   1276   list = g_browser_process->local_state()->GetList(
   1277       ::prefs::kAutofillDialogWalletLocationAcceptance);
   1278   ASSERT_EQ(2U, list->GetSize());
   1279   EXPECT_NE(list->end(), list->Find(base::StringValue(kFakeEmail)));
   1280   EXPECT_NE(list->end(), list->Find(base::StringValue(kOtherUsername)));
   1281 
   1282   // Now check the list doesn't change if the user cancels out of the dialog.
   1283   Reset();
   1284   list = g_browser_process->local_state()->GetList(
   1285       ::prefs::kAutofillDialogWalletLocationAcceptance);
   1286   ASSERT_TRUE(list->empty());
   1287 
   1288   g_browser_process->local_state()->Set(
   1289       ::prefs::kAutofillDialogWalletLocationAcceptance,
   1290       preexisting_list);
   1291 
   1292   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1293   EXPECT_FALSE(controller()->LegalDocumentsText().empty());
   1294   EXPECT_TRUE(controller()->LegalDocumentLinks().empty());
   1295   controller()->OnCancel();
   1296 
   1297   list = g_browser_process->local_state()->GetList(
   1298       ::prefs::kAutofillDialogWalletLocationAcceptance);
   1299   ASSERT_EQ(1U, list->GetSize());
   1300   EXPECT_NE(list->end(), list->Find(base::StringValue(kOtherUsername)));
   1301   EXPECT_EQ(list->end(), list->Find(base::StringValue(kFakeEmail)));
   1302 }
   1303 
   1304 TEST_F(AutofillDialogControllerTest, LegalDocumentOverflow) {
   1305   for (size_t number_of_docs = 2; number_of_docs < 11; ++number_of_docs) {
   1306     scoped_ptr<wallet::WalletItems> wallet_items =
   1307         CompleteAndValidWalletItems();
   1308     for (size_t i = 0; i < number_of_docs; ++i)
   1309       wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   1310 
   1311     Reset();
   1312     controller()->OnDidGetWalletItems(wallet_items.Pass());
   1313 
   1314     // The dialog is only equipped to handle 2-6 legal documents. More than
   1315     // 6 errors out.
   1316     if (number_of_docs <= 6U) {
   1317       EXPECT_FALSE(controller()->LegalDocumentsText().empty());
   1318     } else {
   1319       EXPECT_TRUE(controller()->LegalDocumentsText().empty());
   1320       EXPECT_EQ(1U, NotificationsOfType(
   1321           DialogNotification::WALLET_ERROR).size());
   1322     }
   1323   }
   1324 
   1325   controller()->OnCancel();
   1326 }
   1327 
   1328 // Makes sure the default object IDs are respected.
   1329 TEST_F(AutofillDialogControllerTest, WalletDefaultItems) {
   1330   scoped_ptr<wallet::WalletItems> wallet_items =
   1331       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1332   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1333   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1334   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1335   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1336 
   1337   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   1338   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   1339   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   1340   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   1341   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   1342 
   1343   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1344   // "add", "manage", and 4 suggestions.
   1345   EXPECT_EQ(6,
   1346       controller()->MenuModelForSection(SECTION_CC_BILLING)->GetItemCount());
   1347   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING)->
   1348       IsItemCheckedAt(2));
   1349   ASSERT_FALSE(controller()->IsEditingExistingData(SECTION_CC_BILLING));
   1350   // "use billing", "add", "manage", and 5 suggestions.
   1351   EXPECT_EQ(8,
   1352       controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
   1353   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_SHIPPING)->
   1354       IsItemCheckedAt(4));
   1355   ASSERT_FALSE(controller()->IsEditingExistingData(SECTION_SHIPPING));
   1356 }
   1357 
   1358 // Tests that invalid and AMEX default instruments are ignored.
   1359 TEST_F(AutofillDialogControllerTest, SelectInstrument) {
   1360   scoped_ptr<wallet::WalletItems> wallet_items =
   1361       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1362   // Tests if default instrument is invalid, then, the first valid instrument is
   1363   // selected instead of the default instrument.
   1364   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1365   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1366   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentInvalid());
   1367   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1368 
   1369   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1370   // 4 suggestions and "add", "manage".
   1371   EXPECT_EQ(6,
   1372       controller()->MenuModelForSection(SECTION_CC_BILLING)->GetItemCount());
   1373   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING)->
   1374       IsItemCheckedAt(0));
   1375 
   1376   // Tests if default instrument is AMEX but Wallet doesn't support
   1377   // AMEX on this merchant, then the first valid instrument is
   1378   // selected instead of the default instrument.
   1379   wallet_items = wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1380   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1381   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1382   wallet_items->AddInstrument(
   1383       wallet::GetTestMaskedInstrumentAmex(wallet::AMEX_DISALLOWED));
   1384   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1385 
   1386   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1387   // 4 suggestions and "add", "manage".
   1388   EXPECT_EQ(6,
   1389       controller()->MenuModelForSection(SECTION_CC_BILLING)->GetItemCount());
   1390   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING)->
   1391       IsItemCheckedAt(0));
   1392 
   1393   // Tests if default instrument is AMEX and it is allowed on this merchant,
   1394   // then it is selected.
   1395   wallet_items = wallet::GetTestWalletItems(wallet::AMEX_ALLOWED);
   1396   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1397   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1398   wallet_items->AddInstrument(
   1399       wallet::GetTestMaskedInstrumentAmex(wallet::AMEX_ALLOWED));
   1400   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   1401 
   1402   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1403   // 4 suggestions and "add", "manage".
   1404   EXPECT_EQ(6,
   1405       controller()->MenuModelForSection(SECTION_CC_BILLING)->GetItemCount());
   1406   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING)->
   1407       IsItemCheckedAt(2));
   1408 
   1409   // Tests if only have AMEX and invalid instrument, then "add" is selected.
   1410   wallet_items = wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1411   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentInvalid());
   1412   wallet_items->AddInstrument(
   1413       wallet::GetTestMaskedInstrumentAmex(wallet::AMEX_DISALLOWED));
   1414 
   1415   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1416   // 2 suggestions and "add", "manage".
   1417   EXPECT_EQ(4,
   1418       controller()->MenuModelForSection(SECTION_CC_BILLING)->GetItemCount());
   1419   // "add"
   1420   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING)->
   1421       IsItemCheckedAt(2));
   1422 }
   1423 
   1424 TEST_F(AutofillDialogControllerTest, SaveAddress) {
   1425   EXPECT_CALL(*controller()->GetView(), ModelChanged());
   1426   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1427               SaveToWalletMock(testing::IsNull(),
   1428                                testing::NotNull(),
   1429                                testing::IsNull(),
   1430                                testing::IsNull()));
   1431 
   1432   scoped_ptr<wallet::WalletItems> wallet_items =
   1433       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1434   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1435   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1436   // If there is no shipping address in wallet, it will default to
   1437   // "same-as-billing" instead of "add-new-item". "same-as-billing" is covered
   1438   // by the following tests. The penultimate item in the menu is "add-new-item".
   1439   ui::MenuModel* shipping_model =
   1440       controller()->MenuModelForSection(SECTION_SHIPPING);
   1441   shipping_model->ActivatedAt(shipping_model->GetItemCount() - 2);
   1442 
   1443   AutofillProfile test_profile(test::GetVerifiedProfile());
   1444   FillInputs(SECTION_SHIPPING, test_profile);
   1445 
   1446   AcceptAndLoadFakeFingerprint();
   1447 }
   1448 
   1449 TEST_F(AutofillDialogControllerTest, SaveInstrument) {
   1450   EXPECT_CALL(*controller()->GetView(), ModelChanged());
   1451   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1452               SaveToWalletMock(testing::NotNull(),
   1453                                testing::IsNull(),
   1454                                testing::IsNull(),
   1455                                testing::IsNull()));
   1456 
   1457   FillCCBillingInputs();
   1458   scoped_ptr<wallet::WalletItems> wallet_items =
   1459       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1460   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   1461   SubmitWithWalletItems(wallet_items.Pass());
   1462 }
   1463 
   1464 TEST_F(AutofillDialogControllerTest, SaveInstrumentWithInvalidInstruments) {
   1465   EXPECT_CALL(*controller()->GetView(), ModelChanged());
   1466   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1467               SaveToWalletMock(testing::NotNull(),
   1468                                testing::IsNull(),
   1469                                testing::IsNull(),
   1470                                testing::IsNull()));
   1471 
   1472   FillCCBillingInputs();
   1473   scoped_ptr<wallet::WalletItems> wallet_items =
   1474       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1475   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   1476   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentInvalid());
   1477   SubmitWithWalletItems(wallet_items.Pass());
   1478 }
   1479 
   1480 TEST_F(AutofillDialogControllerTest, SaveInstrumentAndAddress) {
   1481   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1482               SaveToWalletMock(testing::NotNull(),
   1483                                testing::NotNull(),
   1484                                testing::IsNull(),
   1485                                testing::IsNull()));
   1486 
   1487   FillCCBillingInputs();
   1488   scoped_ptr<wallet::WalletItems> wallet_items =
   1489       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1490   SubmitWithWalletItems(wallet_items.Pass());
   1491 }
   1492 
   1493 MATCHER(IsUpdatingExistingData, "updating existing Wallet data") {
   1494   return !arg->object_id().empty();
   1495 }
   1496 
   1497 MATCHER(UsesLocalBillingAddress, "uses the local billing address") {
   1498   return arg->address_line_1() == ASCIIToUTF16(kEditedBillingAddress);
   1499 }
   1500 
   1501 // Tests that when using billing address for shipping, and there is no exact
   1502 // matched shipping address, then a shipping address should be added.
   1503 TEST_F(AutofillDialogControllerTest, BillingForShipping) {
   1504   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1505               SaveToWalletMock(testing::IsNull(),
   1506                                testing::NotNull(),
   1507                                testing::IsNull(),
   1508                                testing::IsNull()));
   1509 
   1510   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1511   // Select "Same as billing" in the address menu.
   1512   UseBillingForShipping();
   1513 
   1514   AcceptAndLoadFakeFingerprint();
   1515 }
   1516 
   1517 // Tests that when using billing address for shipping, and there is an exact
   1518 // matched shipping address, then a shipping address should not be added.
   1519 TEST_F(AutofillDialogControllerTest, BillingForShippingHasMatch) {
   1520   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1521               SaveToWalletMock(_, _, _, _)).Times(0);
   1522 
   1523   scoped_ptr<wallet::WalletItems> wallet_items =
   1524       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1525   scoped_ptr<wallet::WalletItems::MaskedInstrument> instrument =
   1526       wallet::GetTestMaskedInstrument();
   1527   // Copy billing address as shipping address, and assign an id to it.
   1528   scoped_ptr<wallet::Address> shipping_address(
   1529       new wallet::Address(instrument->address()));
   1530   shipping_address->set_object_id("shipping_address_id");
   1531   wallet_items->AddAddress(shipping_address.Pass());
   1532   wallet_items->AddInstrument(instrument.Pass());
   1533   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   1534 
   1535   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1536   // Select "Same as billing" in the address menu.
   1537   UseBillingForShipping();
   1538 
   1539   AcceptAndLoadFakeFingerprint();
   1540 }
   1541 
   1542 // Test that the local view contents is used when saving a new instrument and
   1543 // the user has selected "Same as billing".
   1544 TEST_F(AutofillDialogControllerTest, SaveInstrumentSameAsBilling) {
   1545   scoped_ptr<wallet::WalletItems> wallet_items =
   1546       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1547   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1548   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1549 
   1550   ui::MenuModel* model = controller()->MenuModelForSection(SECTION_CC_BILLING);
   1551   model->ActivatedAt(model->GetItemCount() - 2);
   1552 
   1553   FieldValueMap outputs;
   1554   const DetailInputs& inputs =
   1555       controller()->RequestedFieldsForSection(SECTION_CC_BILLING);
   1556   AutofillProfile full_profile(test::GetVerifiedProfile());
   1557   CreditCard full_card(test::GetCreditCard());
   1558   for (size_t i = 0; i < inputs.size(); ++i) {
   1559     const ServerFieldType type = inputs[i].type;
   1560     if (type == ADDRESS_BILLING_LINE1)
   1561       outputs[type] = ASCIIToUTF16(kEditedBillingAddress);
   1562     else
   1563       outputs[type] = full_profile.GetInfo(AutofillType(type), "en-US");
   1564 
   1565     if (outputs[type].empty())
   1566       outputs[type] = full_card.GetInfo(AutofillType(type), "en-US");
   1567   }
   1568   controller()->GetView()->SetUserInput(SECTION_CC_BILLING, outputs);
   1569 
   1570   controller()->OnAccept();
   1571 
   1572   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1573               SaveToWalletMock(testing::NotNull(),
   1574                                UsesLocalBillingAddress(),
   1575                                testing::IsNull(),
   1576                                testing::IsNull()));
   1577   AcceptAndLoadFakeFingerprint();
   1578 }
   1579 
   1580 TEST_F(AutofillDialogControllerTest, CancelNoSave) {
   1581   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1582               SaveToWalletMock(_, _, _, _)).Times(0);
   1583 
   1584   EXPECT_CALL(*controller()->GetView(), ModelChanged());
   1585 
   1586   controller()->OnDidGetWalletItems(
   1587       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED));
   1588   controller()->OnCancel();
   1589 }
   1590 
   1591 // Checks that clicking the Manage menu item opens a new tab with a different
   1592 // URL for Wallet and Autofill.
   1593 TEST_F(AutofillDialogControllerTest, ManageItem) {
   1594   AutofillProfile full_profile(test::GetVerifiedProfile());
   1595   full_profile.set_origin(kSettingsOrigin);
   1596   full_profile.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
   1597   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1598   SwitchToAutofill();
   1599 
   1600   SuggestionsMenuModel* shipping = GetMenuModelForSection(SECTION_SHIPPING);
   1601   shipping->ExecuteCommand(shipping->GetItemCount() - 1, 0);
   1602   GURL autofill_manage_url = controller()->open_tab_url();
   1603   EXPECT_EQ("chrome", autofill_manage_url.scheme());
   1604 
   1605   SwitchToWallet();
   1606   scoped_ptr<wallet::WalletItems> wallet_items =
   1607       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1608   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1609   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1610 
   1611   controller()->SuggestionItemSelected(shipping, shipping->GetItemCount() - 1);
   1612   GURL wallet_manage_addresses_url = controller()->open_tab_url();
   1613   EXPECT_EQ("https", wallet_manage_addresses_url.scheme());
   1614 
   1615   SuggestionsMenuModel* billing = GetMenuModelForSection(SECTION_CC_BILLING);
   1616   controller()->SuggestionItemSelected(billing, billing->GetItemCount() - 1);
   1617   GURL wallet_manage_instruments_url = controller()->open_tab_url();
   1618   EXPECT_EQ("https", wallet_manage_instruments_url.scheme());
   1619 
   1620   EXPECT_NE(autofill_manage_url, wallet_manage_instruments_url);
   1621   EXPECT_NE(wallet_manage_instruments_url, wallet_manage_addresses_url);
   1622 }
   1623 
   1624 // Tests that adding an autofill profile and then submitting works.
   1625 TEST_F(AutofillDialogControllerTest, AddAutofillProfile) {
   1626   SwitchToAutofill();
   1627   EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(2);
   1628 
   1629   AutofillProfile full_profile(test::GetVerifiedProfile());
   1630   CreditCard credit_card(test::GetVerifiedCreditCard());
   1631   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1632   controller()->GetTestingManager()->AddTestingCreditCard(&credit_card);
   1633 
   1634   ui::MenuModel* model = controller()->MenuModelForSection(SECTION_BILLING);
   1635   // Activate the "Add billing address" menu item.
   1636   model->ActivatedAt(model->GetItemCount() - 2);
   1637 
   1638   // Fill in the inputs from the profile.
   1639   FieldValueMap outputs;
   1640   const DetailInputs& inputs =
   1641       controller()->RequestedFieldsForSection(SECTION_BILLING);
   1642   AutofillProfile full_profile2(test::GetVerifiedProfile2());
   1643   for (size_t i = 0; i < inputs.size(); ++i) {
   1644     const ServerFieldType type = inputs[i].type;
   1645     outputs[type] = full_profile2.GetInfo(AutofillType(type), "en-US");
   1646   }
   1647   controller()->GetView()->SetUserInput(SECTION_BILLING, outputs);
   1648 
   1649   controller()->OnAccept();
   1650   const AutofillProfile& added_profile =
   1651       controller()->GetTestingManager()->imported_profile();
   1652 
   1653   const DetailInputs& shipping_inputs =
   1654       controller()->RequestedFieldsForSection(SECTION_SHIPPING);
   1655   for (size_t i = 0; i < shipping_inputs.size(); ++i) {
   1656     const ServerFieldType type = shipping_inputs[i].type;
   1657     EXPECT_EQ(full_profile2.GetInfo(AutofillType(type), "en-US"),
   1658               added_profile.GetInfo(AutofillType(type), "en-US"));
   1659   }
   1660 }
   1661 
   1662 TEST_F(AutofillDialogControllerTest, VerifyCvv) {
   1663   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetFullWallet(_));
   1664   EXPECT_CALL(*controller()->GetTestingWalletClient(),
   1665               AuthenticateInstrument(_, _));
   1666 
   1667   SubmitWithWalletItems(CompleteAndValidWalletItems());
   1668 
   1669   EXPECT_TRUE(NotificationsOfType(DialogNotification::REQUIRED_ACTION).empty());
   1670   EXPECT_TRUE(controller()->SectionIsActive(SECTION_SHIPPING));
   1671   EXPECT_TRUE(controller()->SectionIsActive(SECTION_CC_BILLING));
   1672   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1673   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1674 
   1675   SuggestionState suggestion_state =
   1676       controller()->SuggestionStateForSection(SECTION_CC_BILLING);
   1677   EXPECT_TRUE(suggestion_state.extra_text.empty());
   1678 
   1679   controller()->OnDidGetFullWallet(
   1680       wallet::GetTestFullWalletWithRequiredActions(
   1681           std::vector<wallet::RequiredAction>(1, wallet::VERIFY_CVV)));
   1682   ASSERT_TRUE(controller()->IsSubmitPausedOn(wallet::VERIFY_CVV));
   1683 
   1684   EXPECT_FALSE(
   1685       NotificationsOfType(DialogNotification::REQUIRED_ACTION).empty());
   1686   EXPECT_FALSE(controller()->SectionIsActive(SECTION_SHIPPING));
   1687   EXPECT_TRUE(controller()->SectionIsActive(SECTION_CC_BILLING));
   1688 
   1689   suggestion_state =
   1690       controller()->SuggestionStateForSection(SECTION_CC_BILLING);
   1691   EXPECT_FALSE(suggestion_state.extra_text.empty());
   1692   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC_BILLING));
   1693 
   1694   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1695   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1696 
   1697   controller()->OnAccept();
   1698 
   1699   EXPECT_FALSE(controller()->GetDialogOverlay().image.IsEmpty());
   1700 }
   1701 
   1702 TEST_F(AutofillDialogControllerTest, ErrorDuringSubmit) {
   1703   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetFullWallet(_));
   1704 
   1705   SubmitWithWalletItems(CompleteAndValidWalletItems());
   1706 
   1707   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1708   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1709 
   1710   controller()->OnWalletError(wallet::WalletClient::UNKNOWN_ERROR);
   1711 
   1712   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1713   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1714 }
   1715 
   1716 TEST_F(AutofillDialogControllerTest, ErrorDuringVerifyCvv) {
   1717   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetFullWallet(_));
   1718 
   1719   SubmitWithWalletItems(CompleteAndValidWalletItems());
   1720   controller()->OnDidGetFullWallet(
   1721       wallet::GetTestFullWalletWithRequiredActions(
   1722           std::vector<wallet::RequiredAction>(1, wallet::VERIFY_CVV)));
   1723 
   1724   ASSERT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1725   ASSERT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1726 
   1727   controller()->OnWalletError(wallet::WalletClient::UNKNOWN_ERROR);
   1728 
   1729   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1730   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_CANCEL));
   1731 }
   1732 
   1733 // Simulates receiving an INVALID_FORM_FIELD required action while processing a
   1734 // |WalletClientDelegate::OnDid{Save,Update}*()| call. This can happen if Online
   1735 // Wallet's server validation differs from Chrome's local validation.
   1736 TEST_F(AutofillDialogControllerTest, WalletServerSideValidation) {
   1737   scoped_ptr<wallet::WalletItems> wallet_items =
   1738       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1739   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1740   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1741   controller()->OnAccept();
   1742 
   1743   std::vector<wallet::RequiredAction> required_actions;
   1744   required_actions.push_back(wallet::INVALID_FORM_FIELD);
   1745 
   1746   std::vector<wallet::FormFieldError> form_errors;
   1747   form_errors.push_back(
   1748       wallet::FormFieldError(wallet::FormFieldError::INVALID_POSTAL_CODE,
   1749                              wallet::FormFieldError::SHIPPING_ADDRESS));
   1750 
   1751   EXPECT_CALL(*controller()->GetView(), UpdateForErrors());
   1752   controller()->OnDidSaveToWallet(std::string(),
   1753                                   std::string(),
   1754                                   required_actions,
   1755                                   form_errors);
   1756 }
   1757 
   1758 // Simulates receiving unrecoverable Wallet server validation errors.
   1759 TEST_F(AutofillDialogControllerTest, WalletServerSideValidationUnrecoverable) {
   1760   scoped_ptr<wallet::WalletItems> wallet_items =
   1761       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1762   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1763   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1764   controller()->OnAccept();
   1765 
   1766   std::vector<wallet::RequiredAction> required_actions;
   1767   required_actions.push_back(wallet::INVALID_FORM_FIELD);
   1768 
   1769   std::vector<wallet::FormFieldError> form_errors;
   1770   form_errors.push_back(
   1771       wallet::FormFieldError(wallet::FormFieldError::UNKNOWN_ERROR,
   1772                              wallet::FormFieldError::UNKNOWN_LOCATION));
   1773 
   1774   controller()->OnDidSaveToWallet(std::string(),
   1775                                   std::string(),
   1776                                   required_actions,
   1777                                   form_errors);
   1778 
   1779   EXPECT_EQ(1U, NotificationsOfType(
   1780       DialogNotification::REQUIRED_ACTION).size());
   1781 }
   1782 
   1783 // Test Wallet banners are show in the right situations. These banners promote
   1784 // saving details into Wallet (i.e. "[x] Save details to Wallet").
   1785 TEST_F(AutofillDialogControllerTest, WalletBanners) {
   1786   // Simulate non-signed-in case.
   1787   SetUpControllerWithFormData(DefaultFormData());
   1788   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
   1789   controller()->OnPassiveSigninFailure(error);
   1790   EXPECT_EQ(0U, NotificationsOfType(
   1791       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1792 
   1793   // Sign in a user with a completed account.
   1794   SetUpControllerWithFormData(DefaultFormData());
   1795   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1796 
   1797   // Full account; should show "Details from Wallet" message.
   1798   EXPECT_EQ(1U, NotificationsOfType(
   1799       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1800   SwitchToAutofill();
   1801   EXPECT_EQ(1U, NotificationsOfType(
   1802       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1803 
   1804   // Start over and sign in a user with an incomplete account.
   1805   SetUpControllerWithFormData(DefaultFormData());
   1806   scoped_ptr<wallet::WalletItems> wallet_items =
   1807       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1808   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1809   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1810 
   1811   // Partial account.
   1812   EXPECT_EQ(1U, NotificationsOfType(
   1813       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1814 
   1815   SwitchToAutofill();
   1816   EXPECT_EQ(1U, NotificationsOfType(
   1817       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1818 
   1819   // A Wallet error should kill any Wallet promos.
   1820   controller()->OnWalletError(wallet::WalletClient::UNKNOWN_ERROR);
   1821 
   1822   EXPECT_EQ(1U, NotificationsOfType(
   1823       DialogNotification::WALLET_ERROR).size());
   1824   EXPECT_EQ(0U, NotificationsOfType(
   1825       DialogNotification::WALLET_USAGE_CONFIRMATION).size());
   1826 }
   1827 
   1828 TEST_F(AutofillDialogControllerTest, ViewCancelDoesntSetPref) {
   1829   ASSERT_FALSE(profile()->GetPrefs()->HasPrefPath(
   1830       ::prefs::kAutofillDialogPayWithoutWallet));
   1831 
   1832   SwitchToAutofill();
   1833 
   1834   controller()->OnCancel();
   1835   controller()->ViewClosed();
   1836 
   1837   EXPECT_FALSE(profile()->GetPrefs()->HasPrefPath(
   1838       ::prefs::kAutofillDialogPayWithoutWallet));
   1839 }
   1840 
   1841 TEST_F(AutofillDialogControllerTest, SubmitWithSigninErrorDoesntSetPref) {
   1842   ASSERT_FALSE(profile()->GetPrefs()->HasPrefPath(
   1843       ::prefs::kAutofillDialogPayWithoutWallet));
   1844 
   1845   SimulateSigninError();
   1846   FillCreditCardInputs();
   1847   controller()->OnAccept();
   1848 
   1849   EXPECT_FALSE(profile()->GetPrefs()->HasPrefPath(
   1850       ::prefs::kAutofillDialogPayWithoutWallet));
   1851 }
   1852 
   1853 // Tests that there's an overlay shown while waiting for full wallet items.
   1854 TEST_F(AutofillDialogControllerTest, WalletFirstRun) {
   1855   EXPECT_TRUE(controller()->GetDialogOverlay().image.IsEmpty());
   1856 
   1857   SubmitWithWalletItems(CompleteAndValidWalletItems());
   1858   EXPECT_FALSE(controller()->GetDialogOverlay().image.IsEmpty());
   1859 
   1860   controller()->OnDidGetFullWallet(wallet::GetTestFullWallet());
   1861   EXPECT_FALSE(controller()->GetDialogOverlay().image.IsEmpty());
   1862   EXPECT_FALSE(form_structure());
   1863 
   1864   // Don't make the test wait for 2 seconds.
   1865   controller()->ForceFinishSubmit();
   1866   EXPECT_TRUE(form_structure());
   1867 }
   1868 
   1869 TEST_F(AutofillDialogControllerTest, ViewSubmitSetsPref) {
   1870   ASSERT_FALSE(profile()->GetPrefs()->HasPrefPath(
   1871       ::prefs::kAutofillDialogPayWithoutWallet));
   1872 
   1873   SwitchToAutofill();
   1874   FillCreditCardInputs();
   1875   controller()->OnAccept();
   1876 
   1877   EXPECT_TRUE(profile()->GetPrefs()->HasPrefPath(
   1878       ::prefs::kAutofillDialogPayWithoutWallet));
   1879   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
   1880       ::prefs::kAutofillDialogPayWithoutWallet));
   1881 
   1882   // Try again with a signin error (just leaves the pref alone).
   1883   SetUpControllerWithFormData(DefaultFormData());
   1884 
   1885   // Setting up the controller again should not change the pref.
   1886   EXPECT_TRUE(profile()->GetPrefs()->HasPrefPath(
   1887       ::prefs::kAutofillDialogPayWithoutWallet));
   1888   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
   1889       ::prefs::kAutofillDialogPayWithoutWallet));
   1890 
   1891   SimulateSigninError();
   1892   FillCreditCardInputs();
   1893   controller()->OnAccept();
   1894   EXPECT_TRUE(profile()->GetPrefs()->HasPrefPath(
   1895       ::prefs::kAutofillDialogPayWithoutWallet));
   1896   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
   1897       ::prefs::kAutofillDialogPayWithoutWallet));
   1898 
   1899   // Successfully choosing wallet does set the pref.
   1900   // Note that OnDidGetWalletItems sets the account chooser to wallet mode.
   1901   SetUpControllerWithFormData(DefaultFormData());
   1902 
   1903   controller()->OnDidFetchWalletCookieValue(std::string());
   1904   scoped_ptr<wallet::WalletItems> wallet_items =
   1905       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   1906   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   1907   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1908   controller()->OnAccept();
   1909   controller()->OnDidGetFullWallet(wallet::GetTestFullWallet());
   1910   controller()->ForceFinishSubmit();
   1911 
   1912   EXPECT_TRUE(profile()->GetPrefs()->HasPrefPath(
   1913       ::prefs::kAutofillDialogPayWithoutWallet));
   1914   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
   1915       ::prefs::kAutofillDialogPayWithoutWallet));
   1916 }
   1917 
   1918 TEST_F(AutofillDialogControllerTest, HideWalletEmail) {
   1919   SwitchToAutofill();
   1920 
   1921   // Email field should be showing when using Autofill.
   1922   EXPECT_TRUE(controller()->SectionIsActive(SECTION_BILLING));
   1923   EXPECT_FALSE(controller()->SectionIsActive(SECTION_CC_BILLING));
   1924   EXPECT_TRUE(SectionContainsField(SECTION_BILLING, EMAIL_ADDRESS));
   1925 
   1926   SwitchToWallet();
   1927 
   1928   // Reset the wallet state.
   1929   controller()->OnDidGetWalletItems(scoped_ptr<wallet::WalletItems>());
   1930 
   1931   // Setup some wallet state, submit, and get a full wallet to end the flow.
   1932   scoped_ptr<wallet::WalletItems> wallet_items = CompleteAndValidWalletItems();
   1933 
   1934   // Filling |form_structure()| depends on the current username and wallet items
   1935   // being fetched. Until both of these have occurred, the user should not be
   1936   // able to click Submit if using Wallet. The username fetch happened earlier.
   1937   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1938   controller()->OnDidGetWalletItems(wallet_items.Pass());
   1939   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   1940 
   1941   // Email field should be absent when using Wallet.
   1942   EXPECT_FALSE(controller()->SectionIsActive(SECTION_BILLING));
   1943   EXPECT_TRUE(controller()->SectionIsActive(SECTION_CC_BILLING));
   1944   EXPECT_FALSE(SectionContainsField(SECTION_CC_BILLING, EMAIL_ADDRESS));
   1945 
   1946   controller()->OnAccept();
   1947   controller()->OnDidGetFullWallet(wallet::GetTestFullWallet());
   1948   controller()->ForceFinishSubmit();
   1949 
   1950   ASSERT_TRUE(form_structure());
   1951   size_t i = 0;
   1952   for (; i < form_structure()->field_count(); ++i) {
   1953     if (form_structure()->field(i)->Type().GetStorableType() == EMAIL_ADDRESS) {
   1954       EXPECT_EQ(ASCIIToUTF16(kFakeEmail), form_structure()->field(i)->value);
   1955       break;
   1956     }
   1957   }
   1958   EXPECT_LT(i, form_structure()->field_count());
   1959 }
   1960 
   1961 // Test if autofill types of returned form structure are correct for billing
   1962 // entries.
   1963 TEST_F(AutofillDialogControllerTest, AutofillTypes) {
   1964   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   1965   controller()->OnAccept();
   1966   controller()->OnDidGetFullWallet(wallet::GetTestFullWallet());
   1967   controller()->ForceFinishSubmit();
   1968   ASSERT_TRUE(form_structure());
   1969   ASSERT_EQ(20U, form_structure()->field_count());
   1970   EXPECT_EQ(EMAIL_ADDRESS,
   1971             form_structure()->field(0)->Type().GetStorableType());
   1972   EXPECT_EQ(CREDIT_CARD_NUMBER,
   1973             form_structure()->field(2)->Type().GetStorableType());
   1974   EXPECT_EQ(ADDRESS_HOME_STATE,
   1975             form_structure()->field(9)->Type().GetStorableType());
   1976   EXPECT_EQ(ADDRESS_BILLING, form_structure()->field(9)->Type().group());
   1977   EXPECT_EQ(ADDRESS_HOME_STATE,
   1978             form_structure()->field(16)->Type().GetStorableType());
   1979   EXPECT_EQ(ADDRESS_HOME, form_structure()->field(16)->Type().group());
   1980 }
   1981 
   1982 TEST_F(AutofillDialogControllerTest, SaveDetailsInChrome) {
   1983   SwitchToAutofill();
   1984   EXPECT_CALL(*controller()->GetView(), ModelChanged()).Times(2);
   1985 
   1986   AutofillProfile full_profile(test::GetVerifiedProfile());
   1987   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   1988 
   1989   CreditCard card(test::GetVerifiedCreditCard());
   1990   controller()->GetTestingManager()->AddTestingCreditCard(&card);
   1991   EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome());
   1992 
   1993   controller()->MenuModelForSection(SECTION_BILLING)->ActivatedAt(0);
   1994   EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome());
   1995 
   1996   controller()->MenuModelForSection(SECTION_BILLING)->ActivatedAt(1);
   1997   EXPECT_TRUE(controller()->ShouldOfferToSaveInChrome());
   1998 
   1999   profile()->ForceIncognito(true);
   2000   EXPECT_FALSE(controller()->ShouldOfferToSaveInChrome());
   2001 }
   2002 
   2003 // Tests that user is prompted when using instrument with minimal address.
   2004 TEST_F(AutofillDialogControllerTest, UpgradeMinimalAddress) {
   2005   // A minimal address being selected should trigger error validation in the
   2006   // view. Called once for each incomplete suggestion.
   2007   EXPECT_CALL(*controller()->GetView(), UpdateForErrors());
   2008 
   2009   scoped_ptr<wallet::WalletItems> wallet_items =
   2010       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2011   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentWithIdAndAddress(
   2012       "id", wallet::GetTestMinimalAddress()));
   2013   scoped_ptr<wallet::Address> address(wallet::GetTestShippingAddress());
   2014   address->set_is_complete_address(false);
   2015   wallet_items->AddAddress(address.Pass());
   2016   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2017 
   2018   // Assert that dialog's SECTION_CC_BILLING section is in edit mode.
   2019   ASSERT_TRUE(controller()->IsEditingExistingData(SECTION_CC_BILLING));
   2020   // Shipping section should be in edit mode because of
   2021   // is_minimal_shipping_address.
   2022   ASSERT_TRUE(controller()->IsEditingExistingData(SECTION_SHIPPING));
   2023 }
   2024 
   2025 TEST_F(AutofillDialogControllerTest, RiskNeverLoadsWithPendingLegalDocuments) {
   2026   EXPECT_CALL(*controller(), LoadRiskFingerprintData()).Times(0);
   2027 
   2028   scoped_ptr<wallet::WalletItems> wallet_items = CompleteAndValidWalletItems();
   2029   wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   2030   wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   2031   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2032   controller()->OnAccept();
   2033 }
   2034 
   2035 TEST_F(AutofillDialogControllerTest, RiskLoadsAfterAcceptingLegalDocuments) {
   2036   EXPECT_CALL(*controller(), LoadRiskFingerprintData()).Times(0);
   2037 
   2038   scoped_ptr<wallet::WalletItems> wallet_items = CompleteAndValidWalletItems();
   2039   wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   2040   wallet_items->AddLegalDocument(wallet::GetTestLegalDocument());
   2041   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2042 
   2043   testing::Mock::VerifyAndClear(controller());
   2044   EXPECT_CALL(*controller(), LoadRiskFingerprintData());
   2045 
   2046   controller()->OnAccept();
   2047 
   2048   // Simulate a risk load and verify |GetRiskData()| matches the encoded value.
   2049   controller()->OnDidAcceptLegalDocuments();
   2050   controller()->OnDidLoadRiskFingerprintData(GetFakeFingerprint().Pass());
   2051   EXPECT_EQ(kFakeFingerprintEncoded, controller()->GetRiskData());
   2052 }
   2053 
   2054 TEST_F(AutofillDialogControllerTest, NoManageMenuItemForNewWalletUsers) {
   2055   // Make sure the menu model item is created for a returning Wallet user.
   2056   scoped_ptr<wallet::WalletItems> wallet_items =
   2057       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2058   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   2059   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   2060   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2061 
   2062   EXPECT_TRUE(controller()->MenuModelForSection(SECTION_CC_BILLING));
   2063   // "Same as billing", "123 address", "Add address...", and "Manage addresses".
   2064   EXPECT_EQ(
   2065       4, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
   2066 
   2067   // Make sure the menu model item is not created for new Wallet users.
   2068   base::DictionaryValue dict;
   2069   scoped_ptr<base::ListValue> required_actions(new base::ListValue);
   2070   required_actions->AppendString("setup_wallet");
   2071   dict.Set("required_action", required_actions.release());
   2072   controller()->OnDidGetWalletItems(
   2073       wallet::WalletItems::CreateWalletItems(dict).Pass());
   2074 
   2075   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC_BILLING));
   2076   // "Same as billing" and "Add address...".
   2077   EXPECT_EQ(
   2078       2, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
   2079 }
   2080 
   2081 TEST_F(AutofillDialogControllerTest, ShippingSectionCanBeHidden) {
   2082   FormFieldData email_field;
   2083   email_field.autocomplete_attribute = "email";
   2084   FormFieldData cc_field;
   2085   cc_field.autocomplete_attribute = "cc-number";
   2086   FormFieldData billing_field;
   2087   billing_field.autocomplete_attribute = "billing region";
   2088 
   2089   FormData form_data;
   2090   form_data.fields.push_back(email_field);
   2091   form_data.fields.push_back(cc_field);
   2092   form_data.fields.push_back(billing_field);
   2093 
   2094   AutofillProfile full_profile(test::GetVerifiedProfile());
   2095   controller()->GetTestingManager()->AddTestingProfile(&full_profile);
   2096   SetUpControllerWithFormData(form_data);
   2097 
   2098   SwitchToAutofill();
   2099 
   2100   EXPECT_FALSE(controller()->SectionIsActive(SECTION_SHIPPING));
   2101 
   2102   FillCreditCardInputs();
   2103   controller()->OnAccept();
   2104   EXPECT_TRUE(form_structure());
   2105 }
   2106 
   2107 TEST_F(AutofillDialogControllerTest, ShippingSectionCanBeHiddenForWallet) {
   2108   FormFieldData email_field;
   2109   email_field.autocomplete_attribute = "email";
   2110   FormFieldData cc_field;
   2111   cc_field.autocomplete_attribute = "cc-number";
   2112   FormFieldData billing_field;
   2113   billing_field.autocomplete_attribute = "billing region";
   2114 
   2115   FormData form_data;
   2116   form_data.fields.push_back(email_field);
   2117   form_data.fields.push_back(cc_field);
   2118   form_data.fields.push_back(billing_field);
   2119 
   2120   SetUpControllerWithFormData(form_data);
   2121   EXPECT_FALSE(controller()->SectionIsActive(SECTION_SHIPPING));
   2122   EXPECT_FALSE(controller()->IsShippingAddressRequired());
   2123 
   2124   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetFullWallet(_));
   2125   scoped_ptr<wallet::WalletItems> wallet_items =
   2126       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2127   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   2128   SubmitWithWalletItems(wallet_items.Pass());
   2129   controller()->OnDidGetFullWallet(wallet::GetTestFullWalletInstrumentOnly());
   2130   controller()->ForceFinishSubmit();
   2131   EXPECT_TRUE(form_structure());
   2132 }
   2133 
   2134 TEST_F(AutofillDialogControllerTest, NotProdNotification) {
   2135   // To make IsPayingWithWallet() true.
   2136   controller()->OnDidGetWalletItems(
   2137       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED));
   2138 
   2139   CommandLine* command_line = CommandLine::ForCurrentProcess();
   2140   ASSERT_EQ(
   2141       "",
   2142       command_line->GetSwitchValueASCII(switches::kWalletServiceUseSandbox));
   2143 
   2144   // Default everywhere is to use prod (no warning).
   2145   EXPECT_EQ(0U,
   2146             NotificationsOfType(DialogNotification::DEVELOPER_WARNING).size());
   2147 
   2148   command_line->AppendSwitchASCII(switches::kWalletServiceUseSandbox, "1");
   2149   EXPECT_EQ(1U,
   2150             NotificationsOfType(DialogNotification::DEVELOPER_WARNING).size());
   2151 }
   2152 
   2153 // Ensure Wallet instruments marked expired by the server are shown as invalid.
   2154 TEST_F(AutofillDialogControllerTest, WalletExpiredCard) {
   2155   scoped_ptr<wallet::WalletItems> wallet_items =
   2156       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2157   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentExpired());
   2158   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2159 
   2160   EXPECT_TRUE(controller()->IsEditingExistingData(SECTION_CC_BILLING));
   2161 
   2162   const DetailInputs& inputs =
   2163       controller()->RequestedFieldsForSection(SECTION_CC_BILLING);
   2164   FieldValueMap outputs;
   2165   CopyInitialValues(inputs, &outputs);
   2166 
   2167   // The local inputs are invalid because the server said so. They'll
   2168   // stay invalid until they differ from the remotely fetched model.
   2169   ValidityMessages messages = controller()->InputsAreValid(SECTION_CC_BILLING,
   2170                                                            outputs);
   2171   EXPECT_TRUE(messages.HasSureError(CREDIT_CARD_EXP_MONTH));
   2172   EXPECT_TRUE(messages.HasSureError(CREDIT_CARD_EXP_4_DIGIT_YEAR));
   2173 
   2174   // Make the local input year differ from the instrument.
   2175   CopyInitialValues(inputs, &outputs);
   2176   outputs[CREDIT_CARD_EXP_4_DIGIT_YEAR] = ASCIIToUTF16("3002");
   2177   messages = controller()->InputsAreValid(SECTION_CC_BILLING, outputs);
   2178   EXPECT_FALSE(HasAnyError(messages, CREDIT_CARD_EXP_MONTH));
   2179   EXPECT_FALSE(HasAnyError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR));
   2180 
   2181   // Make the local input month differ from the instrument.
   2182   CopyInitialValues(inputs, &outputs);
   2183   outputs[CREDIT_CARD_EXP_MONTH] = ASCIIToUTF16("06");
   2184   messages = controller()->InputsAreValid(SECTION_CC_BILLING, outputs);
   2185   EXPECT_FALSE(HasAnyError(messages, CREDIT_CARD_EXP_MONTH));
   2186   EXPECT_FALSE(HasAnyError(messages, CREDIT_CARD_EXP_4_DIGIT_YEAR));
   2187 }
   2188 
   2189 TEST_F(AutofillDialogControllerTest, ChooseAnotherInstrumentOrAddress) {
   2190   SubmitWithWalletItems(CompleteAndValidWalletItems());
   2191 
   2192   EXPECT_EQ(0U, NotificationsOfType(
   2193       DialogNotification::REQUIRED_ACTION).size());
   2194   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2195   controller()->OnDidGetFullWallet(
   2196       wallet::GetTestFullWalletWithRequiredActions(
   2197           std::vector<wallet::RequiredAction>(
   2198               1, wallet::CHOOSE_ANOTHER_INSTRUMENT_OR_ADDRESS)));
   2199   EXPECT_EQ(1U, NotificationsOfType(
   2200       DialogNotification::REQUIRED_ACTION).size());
   2201   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2202 
   2203   controller()->OnAccept();
   2204   EXPECT_EQ(0U, NotificationsOfType(
   2205       DialogNotification::REQUIRED_ACTION).size());
   2206 }
   2207 
   2208 TEST_F(AutofillDialogControllerTest, NewCardBubbleShown) {
   2209   SwitchToAutofill();
   2210   FillCreditCardInputs();
   2211   controller()->OnAccept();
   2212   controller()->ViewClosed();
   2213 
   2214   EXPECT_EQ(1, mock_new_card_bubble_controller()->bubbles_shown());
   2215   EXPECT_EQ(0, test_generated_bubble_controller()->bubbles_shown());
   2216 }
   2217 
   2218 TEST_F(AutofillDialogControllerTest, GeneratedCardBubbleShown) {
   2219   SubmitWithWalletItems(CompleteAndValidWalletItems());
   2220   controller()->OnDidGetFullWallet(wallet::GetTestFullWallet());
   2221   controller()->ForceFinishSubmit();
   2222   controller()->ViewClosed();
   2223 
   2224   EXPECT_EQ(0, mock_new_card_bubble_controller()->bubbles_shown());
   2225   EXPECT_EQ(1, test_generated_bubble_controller()->bubbles_shown());
   2226 }
   2227 
   2228 // Verify that new Wallet data is fetched when the user switches away from the
   2229 // tab hosting the Autofill dialog and back. Also verify that the user's
   2230 // selection is preserved across this re-fetch.
   2231 TEST_F(AutofillDialogControllerTest, ReloadWalletItemsOnActivation) {
   2232   // Initialize some Wallet data.
   2233   scoped_ptr<wallet::WalletItems> wallet_items =
   2234       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2235   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   2236   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   2237   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   2238   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   2239   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2240 
   2241   // Initially, the default entries should be selected.
   2242   ui::MenuModel* cc_billing_model =
   2243       controller()->MenuModelForSection(SECTION_CC_BILLING);
   2244   ui::MenuModel* shipping_model =
   2245       controller()->MenuModelForSection(SECTION_SHIPPING);
   2246   // "add", "manage", and 2 suggestions.
   2247   ASSERT_EQ(4, cc_billing_model->GetItemCount());
   2248   EXPECT_TRUE(cc_billing_model->IsItemCheckedAt(0));
   2249   // "use billing", "add", "manage", and 2 suggestions.
   2250   ASSERT_EQ(5, shipping_model->GetItemCount());
   2251   EXPECT_TRUE(shipping_model->IsItemCheckedAt(2));
   2252 
   2253   // Select entries other than the defaults.
   2254   cc_billing_model->ActivatedAt(1);
   2255   shipping_model->ActivatedAt(1);
   2256   // 2 suggestions, "add", and "manage".
   2257   ASSERT_EQ(4, cc_billing_model->GetItemCount());
   2258   EXPECT_TRUE(cc_billing_model->IsItemCheckedAt(1));
   2259   // "use billing", 2 suggestions, "add", "manage".
   2260   ASSERT_EQ(5, shipping_model->GetItemCount());
   2261   EXPECT_TRUE(shipping_model-> IsItemCheckedAt(1));
   2262 
   2263   // Simulate switching away from the tab and back.  This should issue a request
   2264   // for wallet items.
   2265   controller()->ClearLastWalletItemsFetchTimestampForTesting();
   2266   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2267   controller()->TabActivated();
   2268 
   2269   // Simulate a response that includes different items.
   2270   wallet_items = wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2271   wallet_items->AddInstrument(wallet::GetTestMaskedInstrumentExpired());
   2272   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   2273   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   2274   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   2275   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2276 
   2277   // The previously selected entries should still be selected.
   2278   // 3 suggestions, "add", and "manage".
   2279   ASSERT_EQ(5, cc_billing_model->GetItemCount());
   2280   EXPECT_TRUE(cc_billing_model->IsItemCheckedAt(2));
   2281   // "use billing", 1 suggestion, "add", and "manage".
   2282   ASSERT_EQ(4, shipping_model->GetItemCount());
   2283   EXPECT_TRUE(shipping_model->IsItemCheckedAt(1));
   2284 }
   2285 
   2286 // Verify that if the default values change when re-fetching Wallet data, these
   2287 // new default values are selected in the dialog.
   2288 TEST_F(AutofillDialogControllerTest,
   2289        ReloadWalletItemsOnActivationWithNewDefaults) {
   2290   // Initialize some Wallet data.
   2291   scoped_ptr<wallet::WalletItems> wallet_items =
   2292       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2293   wallet_items->AddInstrument(wallet::GetTestMaskedInstrument());
   2294   wallet_items->AddInstrument(wallet::GetTestNonDefaultMaskedInstrument());
   2295   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   2296   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   2297   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2298 
   2299   // Initially, the default entries should be selected.
   2300   ui::MenuModel* cc_billing_model =
   2301       controller()->MenuModelForSection(SECTION_CC_BILLING);
   2302   ui::MenuModel* shipping_model =
   2303       controller()->MenuModelForSection(SECTION_SHIPPING);
   2304   // 2 suggestions, "add", and "manage".
   2305   ASSERT_EQ(4, cc_billing_model->GetItemCount());
   2306   EXPECT_TRUE(cc_billing_model->IsItemCheckedAt(0));
   2307   // "use billing", 2 suggestions, "add", and "manage".
   2308   ASSERT_EQ(5, shipping_model->GetItemCount());
   2309   EXPECT_TRUE(shipping_model->IsItemCheckedAt(2));
   2310 
   2311   // Simulate switching away from the tab and back.  This should issue a request
   2312   // for wallet items.
   2313   controller()->ClearLastWalletItemsFetchTimestampForTesting();
   2314   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2315   controller()->TabActivated();
   2316 
   2317   // Simulate a response that includes different default values.
   2318   wallet_items =
   2319       wallet::GetTestWalletItemsWithDefaultIds("new_default_instrument_id",
   2320                                                "new_default_address_id",
   2321                                                wallet::AMEX_DISALLOWED);
   2322   scoped_ptr<wallet::Address> other_address = wallet::GetTestShippingAddress();
   2323   other_address->set_object_id("other_address_id");
   2324   scoped_ptr<wallet::Address> new_default_address =
   2325       wallet::GetTestNonDefaultShippingAddress();
   2326   new_default_address->set_object_id("new_default_address_id");
   2327 
   2328   wallet_items->AddInstrument(
   2329       wallet::GetTestMaskedInstrumentWithId("other_instrument_id"));
   2330   wallet_items->AddInstrument(
   2331       wallet::GetTestMaskedInstrumentWithId("new_default_instrument_id"));
   2332   wallet_items->AddAddress(new_default_address.Pass());
   2333   wallet_items->AddAddress(other_address.Pass());
   2334   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2335 
   2336   // The new default entries should be selected.
   2337   // 2 suggestions, "add", and "manage".
   2338   ASSERT_EQ(4, cc_billing_model->GetItemCount());
   2339   EXPECT_TRUE(cc_billing_model->IsItemCheckedAt(1));
   2340   // "use billing", 2 suggestions, "add", and "manage".
   2341   ASSERT_EQ(5, shipping_model->GetItemCount());
   2342   EXPECT_TRUE(shipping_model->IsItemCheckedAt(1));
   2343 }
   2344 
   2345 TEST_F(AutofillDialogControllerTest, ReloadWithEmptyWalletItems) {
   2346   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2347   controller()->MenuModelForSection(SECTION_CC_BILLING)->ActivatedAt(1);
   2348   controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(1);
   2349 
   2350   controller()->ClearLastWalletItemsFetchTimestampForTesting();
   2351   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2352   controller()->TabActivated();
   2353 
   2354   controller()->OnDidGetWalletItems(
   2355       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED));
   2356 
   2357   EXPECT_FALSE(controller()->MenuModelForSection(SECTION_CC_BILLING));
   2358   EXPECT_EQ(
   2359       3, controller()->MenuModelForSection(SECTION_SHIPPING)->GetItemCount());
   2360 }
   2361 
   2362 TEST_F(AutofillDialogControllerTest, SaveInChromeByDefault) {
   2363   EXPECT_TRUE(controller()->ShouldSaveInChrome());
   2364   SwitchToAutofill();
   2365   FillCreditCardInputs();
   2366   controller()->OnAccept();
   2367   EXPECT_TRUE(controller()->ShouldSaveInChrome());
   2368 }
   2369 
   2370 TEST_F(AutofillDialogControllerTest,
   2371        SaveInChromePreferenceNotRememberedOnCancel) {
   2372   EXPECT_TRUE(controller()->ShouldSaveInChrome());
   2373   SwitchToAutofill();
   2374   controller()->GetView()->CheckSaveDetailsLocallyCheckbox(false);
   2375   controller()->OnCancel();
   2376   EXPECT_TRUE(controller()->ShouldSaveInChrome());
   2377 }
   2378 
   2379 TEST_F(AutofillDialogControllerTest,
   2380        SaveInChromePreferenceRememberedOnSuccess) {
   2381   EXPECT_TRUE(controller()->ShouldSaveInChrome());
   2382   SwitchToAutofill();
   2383   FillCreditCardInputs();
   2384   controller()->GetView()->CheckSaveDetailsLocallyCheckbox(false);
   2385   controller()->OnAccept();
   2386   EXPECT_FALSE(controller()->ShouldSaveInChrome());
   2387 }
   2388 
   2389 TEST_F(AutofillDialogControllerTest,
   2390        SubmitButtonIsDisabled_SpinnerFinishesBeforeDelay) {
   2391   // Reset Wallet state.
   2392   controller()->OnDidGetWalletItems(scoped_ptr<wallet::WalletItems>());
   2393 
   2394   EXPECT_EQ(1, controller()->get_submit_button_delay_count());
   2395 
   2396   // Begin the submit button delay.
   2397   controller()->SimulateSubmitButtonDelayBegin();
   2398 
   2399   EXPECT_TRUE(controller()->ShouldShowSpinner());
   2400   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2401 
   2402   // Stop the spinner.
   2403   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2404 
   2405   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2406   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2407 
   2408   // End the submit button delay.
   2409   controller()->SimulateSubmitButtonDelayEnd();
   2410 
   2411   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2412   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2413 }
   2414 
   2415 TEST_F(AutofillDialogControllerTest,
   2416        SubmitButtonIsDisabled_SpinnerFinishesAfterDelay) {
   2417   // Reset Wallet state.
   2418   controller()->OnDidGetWalletItems(scoped_ptr<wallet::WalletItems>());
   2419 
   2420   EXPECT_EQ(1, controller()->get_submit_button_delay_count());
   2421 
   2422   // Begin the submit button delay.
   2423   controller()->SimulateSubmitButtonDelayBegin();
   2424 
   2425   EXPECT_TRUE(controller()->ShouldShowSpinner());
   2426   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2427 
   2428   // End the submit button delay.
   2429   controller()->SimulateSubmitButtonDelayEnd();
   2430 
   2431   EXPECT_TRUE(controller()->ShouldShowSpinner());
   2432   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2433 
   2434   // Stop the spinner.
   2435   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2436 
   2437   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2438   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2439 }
   2440 
   2441 TEST_F(AutofillDialogControllerTest, SubmitButtonIsDisabled_NoSpinner) {
   2442   SwitchToAutofill();
   2443 
   2444   EXPECT_EQ(1, controller()->get_submit_button_delay_count());
   2445 
   2446   // Begin the submit button delay.
   2447   controller()->SimulateSubmitButtonDelayBegin();
   2448 
   2449   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2450   EXPECT_FALSE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2451 
   2452   // End the submit button delay.
   2453   controller()->SimulateSubmitButtonDelayEnd();
   2454 
   2455   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2456   EXPECT_TRUE(controller()->IsDialogButtonEnabled(ui::DIALOG_BUTTON_OK));
   2457 }
   2458 
   2459 TEST_F(AutofillDialogControllerTest, IconsForFields_NoCreditCard) {
   2460   FieldValueMap values;
   2461   values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail);
   2462   FieldIconMap icons = controller()->IconsForFields(values);
   2463   EXPECT_TRUE(icons.empty());
   2464 }
   2465 
   2466 TEST_F(AutofillDialogControllerTest, IconsForFields_CreditCardNumberOnly) {
   2467   FieldValueMap values;
   2468   values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail);
   2469   values[CREDIT_CARD_NUMBER] = ASCIIToUTF16(kTestCCNumberVisa);
   2470   FieldIconMap icons = controller()->IconsForFields(values);
   2471   EXPECT_EQ(1UL, icons.size());
   2472   EXPECT_EQ(1UL, icons.count(CREDIT_CARD_NUMBER));
   2473 }
   2474 
   2475 TEST_F(AutofillDialogControllerTest, IconsForFields_CvcOnly) {
   2476   FieldValueMap values;
   2477   values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail);
   2478   values[CREDIT_CARD_VERIFICATION_CODE] = ASCIIToUTF16("123");
   2479   FieldIconMap icons = controller()->IconsForFields(values);
   2480   EXPECT_EQ(1UL, icons.size());
   2481   EXPECT_EQ(1UL, icons.count(CREDIT_CARD_VERIFICATION_CODE));
   2482 }
   2483 
   2484 TEST_F(AutofillDialogControllerTest, IconsForFields_BothCreditCardAndCvc) {
   2485   FieldValueMap values;
   2486   values[EMAIL_ADDRESS] = ASCIIToUTF16(kFakeEmail);
   2487   values[CREDIT_CARD_NUMBER] = ASCIIToUTF16(kTestCCNumberVisa);
   2488   values[CREDIT_CARD_VERIFICATION_CODE] = ASCIIToUTF16("123");
   2489   FieldIconMap icons = controller()->IconsForFields(values);
   2490   EXPECT_EQ(2UL, icons.size());
   2491   EXPECT_EQ(1UL, icons.count(CREDIT_CARD_VERIFICATION_CODE));
   2492   EXPECT_EQ(1UL, icons.count(CREDIT_CARD_NUMBER));
   2493 }
   2494 
   2495 TEST_F(AutofillDialogControllerTest, FieldControlsIcons) {
   2496   EXPECT_TRUE(controller()->FieldControlsIcons(CREDIT_CARD_NUMBER));
   2497   EXPECT_FALSE(controller()->FieldControlsIcons(CREDIT_CARD_VERIFICATION_CODE));
   2498   EXPECT_FALSE(controller()->FieldControlsIcons(EMAIL_ADDRESS));
   2499 }
   2500 
   2501 TEST_F(AutofillDialogControllerTest, SaveCreditCardIncludesName_NoBilling) {
   2502   SwitchToAutofill();
   2503 
   2504   CreditCard test_credit_card(test::GetVerifiedCreditCard());
   2505   FillInputs(SECTION_CC, test_credit_card);
   2506 
   2507   AutofillProfile test_profile(test::GetVerifiedProfile());
   2508   FillInputs(SECTION_BILLING, test_profile);
   2509 
   2510   UseBillingForShipping();
   2511 
   2512   controller()->GetView()->CheckSaveDetailsLocallyCheckbox(true);
   2513   controller()->OnAccept();
   2514 
   2515   TestPersonalDataManager* test_pdm = controller()->GetTestingManager();
   2516   const CreditCard& imported_card = test_pdm->imported_credit_card();
   2517   EXPECT_EQ(test_profile.GetRawInfo(NAME_FULL),
   2518             imported_card.GetRawInfo(CREDIT_CARD_NAME));
   2519 }
   2520 
   2521 TEST_F(AutofillDialogControllerTest, SaveCreditCardIncludesName_WithBilling) {
   2522   SwitchToAutofill();
   2523 
   2524   TestPersonalDataManager* test_pdm = controller()->GetTestingManager();
   2525   AutofillProfile test_profile(test::GetVerifiedProfile());
   2526 
   2527   EXPECT_CALL(*controller()->GetView(), ModelChanged());
   2528   test_pdm->AddTestingProfile(&test_profile);
   2529   ASSERT_TRUE(controller()->MenuModelForSection(SECTION_BILLING));
   2530 
   2531   CreditCard test_credit_card(test::GetVerifiedCreditCard());
   2532   FillInputs(SECTION_CC, test_credit_card);
   2533 
   2534   controller()->GetView()->CheckSaveDetailsLocallyCheckbox(true);
   2535   controller()->OnAccept();
   2536 
   2537   const CreditCard& imported_card = test_pdm->imported_credit_card();
   2538   EXPECT_EQ(test_profile.GetRawInfo(NAME_FULL),
   2539             imported_card.GetRawInfo(CREDIT_CARD_NAME));
   2540 
   2541   controller()->ViewClosed();
   2542 }
   2543 
   2544 TEST_F(AutofillDialogControllerTest, InputEditability) {
   2545   // Empty wallet items: all fields are editable.
   2546   scoped_ptr<wallet::WalletItems> items =
   2547       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2548   controller()->OnDidGetWalletItems(items.Pass());
   2549 
   2550   DialogSection sections[] = { SECTION_CC_BILLING, SECTION_SHIPPING };
   2551   for (size_t i = 0; i < arraysize(sections); ++i) {
   2552     const DetailInputs& inputs =
   2553         controller()->RequestedFieldsForSection(sections[i]);
   2554     for (size_t j = 0; j < inputs.size(); ++j) {
   2555       EXPECT_TRUE(controller()->InputIsEditable(inputs[j], sections[i]));
   2556     }
   2557   }
   2558 
   2559   // Expired instrument: CC number + CVV are not editable.
   2560   items = wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2561   scoped_ptr<wallet::WalletItems::MaskedInstrument> expired_instrument =
   2562       wallet::GetTestMaskedInstrumentExpired();
   2563   items->AddInstrument(expired_instrument.Pass());
   2564   controller()->OnDidGetWalletItems(items.Pass());
   2565   EXPECT_TRUE(controller()->IsEditingExistingData(SECTION_CC_BILLING));
   2566 
   2567   const DetailInputs& inputs =
   2568       controller()->RequestedFieldsForSection(SECTION_CC_BILLING);
   2569   FieldValueMap outputs;
   2570   CopyInitialValues(inputs, &outputs);
   2571   controller()->GetView()->SetUserInput(SECTION_CC_BILLING, outputs);
   2572 
   2573   for (size_t i = 0; i < arraysize(sections); ++i) {
   2574     const DetailInputs& inputs =
   2575         controller()->RequestedFieldsForSection(sections[i]);
   2576     for (size_t j = 0; j < inputs.size(); ++j) {
   2577       if (inputs[j].type == CREDIT_CARD_NUMBER ||
   2578           inputs[j].type == CREDIT_CARD_VERIFICATION_CODE) {
   2579         EXPECT_FALSE(controller()->InputIsEditable(inputs[j], sections[i]));
   2580       } else {
   2581         EXPECT_TRUE(controller()->InputIsEditable(inputs[j], sections[i]));
   2582       }
   2583     }
   2584   }
   2585 
   2586   // User changes the billing address; same story.
   2587   outputs[ADDRESS_BILLING_ZIP] = ASCIIToUTF16("77025");
   2588   controller()->GetView()->SetUserInput(SECTION_CC_BILLING, outputs);
   2589   for (size_t i = 0; i < arraysize(sections); ++i) {
   2590     const DetailInputs& inputs =
   2591         controller()->RequestedFieldsForSection(sections[i]);
   2592     for (size_t j = 0; j < inputs.size(); ++j) {
   2593       if (inputs[j].type == CREDIT_CARD_NUMBER ||
   2594           inputs[j].type == CREDIT_CARD_VERIFICATION_CODE) {
   2595         EXPECT_FALSE(controller()->InputIsEditable(inputs[j], sections[i]));
   2596       } else {
   2597         EXPECT_TRUE(controller()->InputIsEditable(inputs[j], sections[i]));
   2598       }
   2599     }
   2600   }
   2601 
   2602   // User changes a detail of the CC itself (expiration date), CVV is now
   2603   // editable (and mandatory).
   2604   outputs[CREDIT_CARD_EXP_MONTH] = ASCIIToUTF16("06");
   2605   controller()->GetView()->SetUserInput(SECTION_CC_BILLING, outputs);
   2606   for (size_t i = 0; i < arraysize(sections); ++i) {
   2607     const DetailInputs& inputs =
   2608         controller()->RequestedFieldsForSection(sections[i]);
   2609     for (size_t j = 0; j < inputs.size(); ++j) {
   2610       if (inputs[j].type == CREDIT_CARD_NUMBER)
   2611         EXPECT_FALSE(controller()->InputIsEditable(inputs[j], sections[i]));
   2612       else
   2613         EXPECT_TRUE(controller()->InputIsEditable(inputs[j], sections[i]));
   2614     }
   2615   }
   2616 }
   2617 
   2618 // When the default country is something besides US, wallet is not selected
   2619 // and the account chooser shouldn't be visible.
   2620 // TODO(estade): this is disabled until http://crbug.com/323641 is fixed.
   2621 TEST_F(AutofillDialogControllerTest, DISABLED_HideWalletInOtherCountries) {
   2622   ResetControllerWithFormData(DefaultFormData());
   2623   controller()->GetTestingManager()->set_default_country_code("US");
   2624   controller()->Show();
   2625   EXPECT_TRUE(
   2626       controller()->AccountChooserModelForTesting()->WalletIsSelected());
   2627   controller()->OnDidFetchWalletCookieValue(std::string());
   2628   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2629   EXPECT_TRUE(controller()->ShouldShowAccountChooser());
   2630   EXPECT_TRUE(
   2631       controller()->AccountChooserModelForTesting()->WalletIsSelected());
   2632 
   2633   ResetControllerWithFormData(DefaultFormData());
   2634   controller()->GetTestingManager()->set_default_country_code("ES");
   2635   controller()->Show();
   2636   EXPECT_FALSE(controller()->ShouldShowAccountChooser());
   2637   EXPECT_FALSE(
   2638       controller()->AccountChooserModelForTesting()->WalletIsSelected());
   2639 }
   2640 
   2641 TEST_F(AutofillDialogControllerTest, DontGetWalletTillNecessary) {
   2642   // When starting on local data mode, the dialog will provide a "Use Google
   2643   // Wallet" link.
   2644   profile()->GetPrefs()->SetBoolean(
   2645       ::prefs::kAutofillDialogPayWithoutWallet, true);
   2646   ResetControllerWithFormData(DefaultFormData());
   2647   controller()->Show();
   2648   base::string16 use_wallet_text = controller()->SignInLinkText();
   2649   EXPECT_EQ(TestAutofillDialogController::NOT_CHECKED,
   2650             controller()->SignedInState());
   2651 
   2652   // When clicked, this link will ask for wallet items. If there's a signin
   2653   // failure, the link will switch to "Sign in to use Google Wallet".
   2654   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2655   controller()->SignInLinkClicked();
   2656   EXPECT_NE(TestAutofillDialogController::NOT_CHECKED,
   2657             controller()->SignedInState());
   2658   controller()->OnDidFetchWalletCookieValue(std::string());
   2659   controller()->OnDidGetWalletItems(CompleteAndValidWalletItems());
   2660   controller()->OnPassiveSigninFailure(GoogleServiceAuthError(
   2661       GoogleServiceAuthError::CONNECTION_FAILED));
   2662   EXPECT_NE(use_wallet_text, controller()->SignInLinkText());
   2663 }
   2664 
   2665 TEST_F(AutofillDialogControllerTest, MultiAccountSwitch) {
   2666   std::vector<std::string> users;
   2667   users.push_back("user_1 (at) example.com");
   2668   users.push_back("user_2 (at) example.com");
   2669   controller()->OnDidGetWalletItems(
   2670       wallet::GetTestWalletItemsWithUsers(users, 0));
   2671 
   2672   // Items should be: Account 1, account 2, add account, disable wallet.
   2673   EXPECT_EQ(4, controller()->MenuModelForAccountChooser()->GetItemCount());
   2674   EXPECT_EQ(0U, controller()->GetTestingWalletClient()->user_index());
   2675 
   2676   // GetWalletItems should be called when the user switches accounts.
   2677   EXPECT_CALL(*controller()->GetTestingWalletClient(), GetWalletItems());
   2678   controller()->MenuModelForAccountChooser()->ActivatedAt(1);
   2679   // The wallet client should be updated to the new user index.
   2680   EXPECT_EQ(1U, controller()->GetTestingWalletClient()->user_index());
   2681 }
   2682 
   2683 TEST_F(AutofillDialogControllerTest, PassiveAuthFailure) {
   2684   controller()->OnDidGetWalletItems(
   2685       wallet::GetTestWalletItemsWithRequiredAction(
   2686            wallet::PASSIVE_GAIA_AUTH));
   2687   EXPECT_TRUE(controller()->ShouldShowSpinner());
   2688   controller()->OnPassiveSigninFailure(GoogleServiceAuthError(
   2689       GoogleServiceAuthError::NONE));
   2690   EXPECT_FALSE(controller()->ShouldShowSpinner());
   2691 }
   2692 
   2693 TEST_F(AutofillDialogControllerTest, WalletShippingSameAsBilling) {
   2694   // Assert initial state.
   2695   ASSERT_FALSE(profile()->GetPrefs()->HasPrefPath(
   2696       ::prefs::kAutofillDialogWalletShippingSameAsBilling));
   2697 
   2698   // Verify that false pref defaults to wallet defaults.
   2699   scoped_ptr<wallet::WalletItems> wallet_items =
   2700       wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2701   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   2702   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   2703   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2704   ASSERT_FALSE(profile()->GetPrefs()->GetBoolean(
   2705       ::prefs::kAutofillDialogWalletShippingSameAsBilling));
   2706   EXPECT_EQ(2, GetMenuModelForSection(SECTION_SHIPPING)->checked_item());
   2707 
   2708   // Set "Same as Billing" for the shipping address and verify it sets the pref
   2709   // and selects the appropriate menu item.
   2710   UseBillingForShipping();
   2711   ASSERT_EQ(0, GetMenuModelForSection(SECTION_SHIPPING)->checked_item());
   2712   controller()->ForceFinishSubmit();
   2713   ASSERT_TRUE(profile()->GetPrefs()->GetBoolean(
   2714       ::prefs::kAutofillDialogWalletShippingSameAsBilling));
   2715 
   2716   // Getting new wallet info shouldn't disrupt the preference and menu should be
   2717   // set accordingly.
   2718   Reset();
   2719   wallet_items = wallet::GetTestWalletItems(wallet::AMEX_DISALLOWED);
   2720   wallet_items->AddAddress(wallet::GetTestNonDefaultShippingAddress());
   2721   wallet_items->AddAddress(wallet::GetTestShippingAddress());
   2722   controller()->OnDidGetWalletItems(wallet_items.Pass());
   2723   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
   2724       ::prefs::kAutofillDialogWalletShippingSameAsBilling));
   2725   EXPECT_EQ(0, GetMenuModelForSection(SECTION_SHIPPING)->checked_item());
   2726 
   2727   // Choose a different address and ensure pref gets set to false.
   2728   controller()->MenuModelForSection(SECTION_SHIPPING)->ActivatedAt(1);
   2729   controller()->ForceFinishSubmit();
   2730   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
   2731       ::prefs::kAutofillDialogWalletShippingSameAsBilling));
   2732 }
   2733 
   2734 }  // namespace autofill
   2735