1 // Copyright 2013 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/strings/utf_string_conversions.h" 8 #include "base/tuple.h" 9 #include "chrome/test/base/chrome_render_view_host_test_harness.h" 10 #include "components/autofill/content/browser/autocheckout_manager.h" 11 #include "components/autofill/core/browser/autofill_common_test.h" 12 #include "components/autofill/core/browser/autofill_manager.h" 13 #include "components/autofill/core/browser/autofill_metrics.h" 14 #include "components/autofill/core/browser/form_structure.h" 15 #include "components/autofill/core/browser/test_autofill_driver.h" 16 #include "components/autofill/core/browser/test_autofill_manager_delegate.h" 17 #include "components/autofill/core/common/autofill_messages.h" 18 #include "components/autofill/core/common/form_data.h" 19 #include "content/public/browser/browser_thread.h" 20 #include "content/public/test/mock_render_process_host.h" 21 #include "content/public/test/test_browser_thread.h" 22 #include "content/public/test/test_utils.h" 23 #include "ipc/ipc_test_sink.h" 24 #include "testing/gmock/include/gmock/gmock.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 27 using content::BrowserThread; 28 29 namespace autofill { 30 31 namespace { 32 33 typedef Tuple4<std::vector<FormData>, 34 std::vector<WebElementDescriptor>, 35 std::vector<WebElementDescriptor>, 36 WebElementDescriptor> AutofillParam; 37 38 enum ProceedElementPresence { 39 NO_PROCEED_ELEMENT, 40 HAS_PROCEED_ELEMENT, 41 }; 42 43 FormFieldData BuildFieldWithValue( 44 const std::string& autocomplete_attribute, 45 const std::string& value) { 46 FormFieldData field; 47 field.name = ASCIIToUTF16(autocomplete_attribute); 48 field.value = ASCIIToUTF16(value); 49 field.autocomplete_attribute = autocomplete_attribute; 50 field.form_control_type = "text"; 51 return field; 52 } 53 54 FormFieldData BuildField(const std::string& autocomplete_attribute) { 55 return BuildFieldWithValue(autocomplete_attribute, autocomplete_attribute); 56 } 57 58 scoped_ptr<FormStructure> CreateTestFormStructure( 59 const std::vector<ServerFieldType>& autofill_types) { 60 FormData form; 61 form.name = ASCIIToUTF16("MyForm"); 62 form.method = ASCIIToUTF16("POST"); 63 form.origin = GURL("https://myform.com/form.html"); 64 form.action = GURL("https://myform.com/submit.html"); 65 form.user_submitted = true; 66 67 // Add some fields, autocomplete_attribute is not important and we 68 // fake that server sends authoritative field mappings. 69 for (size_t i = 0; i < autofill_types.size(); ++i) 70 form.fields.push_back(BuildField("SomeField")); 71 72 scoped_ptr<FormStructure> form_structure( 73 new FormStructure(form, std::string())); 74 75 // Set mocked Autofill server field types. 76 for (size_t i = 0; i < autofill_types.size(); ++i) { 77 form_structure->field(i)->set_server_type(autofill_types[i]); 78 // Set heuristic type to make sure that server_types are used and not 79 // heuritic type. 80 form_structure->field(i)->set_heuristic_type(CREDIT_CARD_NUMBER); 81 } 82 83 return form_structure.Pass(); 84 } 85 86 scoped_ptr<FormStructure> CreateTestAddressFormStructure() { 87 std::vector<ServerFieldType> autofill_types; 88 autofill_types.push_back(NAME_FULL); 89 autofill_types.push_back(PHONE_HOME_WHOLE_NUMBER); 90 autofill_types.push_back(EMAIL_ADDRESS); 91 autofill_types.push_back(ADDRESS_HOME_LINE1); 92 autofill_types.push_back(ADDRESS_HOME_CITY); 93 autofill_types.push_back(ADDRESS_HOME_STATE); 94 autofill_types.push_back(ADDRESS_HOME_COUNTRY); 95 autofill_types.push_back(ADDRESS_HOME_ZIP); 96 autofill_types.push_back(NO_SERVER_DATA); 97 return CreateTestFormStructure(autofill_types); 98 } 99 100 scoped_ptr<FormStructure> CreateTestCreditCardFormStructure() { 101 std::vector<ServerFieldType> autofill_types; 102 autofill_types.push_back(CREDIT_CARD_NAME); 103 autofill_types.push_back(CREDIT_CARD_NUMBER); 104 autofill_types.push_back(CREDIT_CARD_EXP_MONTH); 105 autofill_types.push_back(CREDIT_CARD_EXP_4_DIGIT_YEAR); 106 autofill_types.push_back(CREDIT_CARD_VERIFICATION_CODE); 107 autofill_types.push_back(ADDRESS_BILLING_LINE1); 108 autofill_types.push_back(ADDRESS_BILLING_CITY); 109 autofill_types.push_back(ADDRESS_BILLING_STATE); 110 autofill_types.push_back(ADDRESS_BILLING_COUNTRY); 111 autofill_types.push_back(ADDRESS_BILLING_ZIP); 112 return CreateTestFormStructure(autofill_types); 113 } 114 115 scoped_ptr<FormStructure> CreateTestFormStructureWithDefaultValues() { 116 FormData form; 117 form.name = ASCIIToUTF16("MyForm"); 118 form.method = ASCIIToUTF16("POST"); 119 form.origin = GURL("https://myform.com/form.html"); 120 form.action = GURL("https://myform.com/submit.html"); 121 form.user_submitted = true; 122 123 // Add two radio button fields. 124 FormFieldData male = BuildFieldWithValue("sex", "male"); 125 male.is_checkable = true; 126 form.fields.push_back(male); 127 FormFieldData female = BuildFieldWithValue("sex", "female"); 128 female.is_checkable = true; 129 form.fields.push_back(female); 130 FormFieldData select = BuildField("SelectField"); 131 select.form_control_type = "select-one"; 132 form.fields.push_back(select); 133 134 scoped_ptr<FormStructure> form_structure( 135 new FormStructure(form, std::string())); 136 137 // Fake server response. Set all fields as fields with default value. 138 form_structure->field(0)->set_server_type(FIELD_WITH_DEFAULT_VALUE); 139 form_structure->field(0)->set_default_value("female"); 140 form_structure->field(1)->set_server_type(FIELD_WITH_DEFAULT_VALUE); 141 form_structure->field(1)->set_default_value("female"); 142 form_structure->field(2)->set_server_type(FIELD_WITH_DEFAULT_VALUE); 143 form_structure->field(2)->set_default_value("Default Value"); 144 145 return form_structure.Pass(); 146 } 147 148 void PopulateClickElement(WebElementDescriptor* proceed_element, 149 const std::string& descriptor) { 150 proceed_element->descriptor = descriptor; 151 proceed_element->retrieval_method = WebElementDescriptor::ID; 152 } 153 154 scoped_ptr<AutocheckoutPageMetaData> CreateStartOfFlowMetaData() { 155 scoped_ptr<AutocheckoutPageMetaData> start_of_flow( 156 new AutocheckoutPageMetaData()); 157 start_of_flow->current_page_number = 0; 158 start_of_flow->total_pages = 3; 159 start_of_flow->page_types[0].push_back(AUTOCHECKOUT_STEP_SHIPPING); 160 start_of_flow->page_types[1].push_back(AUTOCHECKOUT_STEP_DELIVERY); 161 start_of_flow->page_types[2].push_back(AUTOCHECKOUT_STEP_BILLING); 162 PopulateClickElement(&start_of_flow->proceed_element_descriptor, "#foo"); 163 return start_of_flow.Pass(); 164 } 165 166 scoped_ptr<AutocheckoutPageMetaData> CreateInFlowMetaData() { 167 scoped_ptr<AutocheckoutPageMetaData> in_flow(new AutocheckoutPageMetaData()); 168 in_flow->current_page_number = 1; 169 in_flow->total_pages = 3; 170 PopulateClickElement(&in_flow->proceed_element_descriptor, "#foo"); 171 return in_flow.Pass(); 172 } 173 174 scoped_ptr<AutocheckoutPageMetaData> CreateNotInFlowMetaData() { 175 scoped_ptr<AutocheckoutPageMetaData> not_in_flow( 176 new AutocheckoutPageMetaData()); 177 PopulateClickElement(¬_in_flow->proceed_element_descriptor, "#foo"); 178 return not_in_flow.Pass(); 179 } 180 181 scoped_ptr<AutocheckoutPageMetaData> CreateEndOfFlowMetaData( 182 ProceedElementPresence proceed_element_presence) { 183 scoped_ptr<AutocheckoutPageMetaData> end_of_flow( 184 new AutocheckoutPageMetaData()); 185 end_of_flow->current_page_number = 2; 186 end_of_flow->total_pages = 3; 187 if (proceed_element_presence == HAS_PROCEED_ELEMENT) 188 PopulateClickElement(&end_of_flow->proceed_element_descriptor, "#foo"); 189 return end_of_flow.Pass(); 190 } 191 192 scoped_ptr<AutocheckoutPageMetaData> CreateOnePageFlowMetaData( 193 ProceedElementPresence proceed_element_presence) { 194 scoped_ptr<AutocheckoutPageMetaData> one_page_flow( 195 new AutocheckoutPageMetaData()); 196 one_page_flow->current_page_number = 0; 197 one_page_flow->total_pages = 1; 198 one_page_flow->page_types[0].push_back(AUTOCHECKOUT_STEP_SHIPPING); 199 one_page_flow->page_types[0].push_back(AUTOCHECKOUT_STEP_DELIVERY); 200 one_page_flow->page_types[0].push_back(AUTOCHECKOUT_STEP_BILLING); 201 if (proceed_element_presence == HAS_PROCEED_ELEMENT) 202 PopulateClickElement(&one_page_flow->proceed_element_descriptor, "#foo"); 203 return one_page_flow.Pass(); 204 } 205 206 scoped_ptr<AutocheckoutPageMetaData> CreateMissingProceedMetaData() { 207 scoped_ptr<AutocheckoutPageMetaData> missing_proceed( 208 new AutocheckoutPageMetaData()); 209 missing_proceed->current_page_number = 1; 210 missing_proceed->total_pages = 3; 211 return missing_proceed.Pass(); 212 } 213 214 scoped_ptr<AutocheckoutPageMetaData> CreateMultiClickMetaData() { 215 scoped_ptr<AutocheckoutPageMetaData> metadata(new AutocheckoutPageMetaData()); 216 metadata->current_page_number = 1; 217 metadata->total_pages = 3; 218 PopulateClickElement(&metadata->proceed_element_descriptor, "#foo"); 219 WebElementDescriptor element; 220 PopulateClickElement(&element, "#before_form_fill_1"); 221 metadata->click_elements_before_form_fill.push_back(element); 222 PopulateClickElement(&element, "#before_form_fill_2"); 223 metadata->click_elements_before_form_fill.push_back(element); 224 PopulateClickElement(&element, "#after_form_fill"); 225 metadata->click_elements_after_form_fill.push_back(element); 226 return metadata.Pass(); 227 } 228 229 struct TestField { 230 const char* const field_type; 231 const char* const field_value; 232 ServerFieldType autofill_type; 233 }; 234 235 const TestField kTestFields[] = { 236 {"name", "Test User", NAME_FULL}, 237 {"tel", "650-123-9909", PHONE_HOME_WHOLE_NUMBER}, 238 {"email", "blah (at) blah.com", EMAIL_ADDRESS}, 239 {"cc-name", "Test User", CREDIT_CARD_NAME}, 240 {"cc-number", "4444444444444448", CREDIT_CARD_NUMBER}, 241 {"cc-exp-month", "10", CREDIT_CARD_EXP_MONTH}, 242 {"cc-exp-year", "2020", CREDIT_CARD_EXP_4_DIGIT_YEAR}, 243 {"cc-csc", "123", CREDIT_CARD_VERIFICATION_CODE}, 244 {"street-address", "Fake Street", ADDRESS_HOME_LINE1}, 245 {"locality", "Mocked City", ADDRESS_HOME_CITY}, 246 {"region", "California", ADDRESS_HOME_STATE}, 247 {"country", "USA", ADDRESS_HOME_COUNTRY}, 248 {"postal-code", "49012", ADDRESS_HOME_ZIP}, 249 {"billing-street-address", "Billing Street", ADDRESS_BILLING_LINE1}, 250 {"billing-locality", "Billing City", ADDRESS_BILLING_CITY}, 251 {"billing-region", "BillingState", ADDRESS_BILLING_STATE}, 252 {"billing-country", "Canada", ADDRESS_BILLING_COUNTRY}, 253 {"billing-postal-code", "11111", ADDRESS_BILLING_ZIP} 254 }; 255 256 // Build Autocheckout specific form data to be consumed by 257 // AutofillDialogController to show the Autocheckout specific UI. 258 scoped_ptr<FormStructure> FakeUserSubmittedFormStructure() { 259 FormData formdata; 260 for (size_t i = 0; i < arraysize(kTestFields); i++) { 261 formdata.fields.push_back( 262 BuildFieldWithValue(kTestFields[i].field_type, 263 kTestFields[i].field_value)); 264 } 265 scoped_ptr<FormStructure> form_structure; 266 form_structure.reset(new FormStructure(formdata, std::string())); 267 for (size_t i = 0; i < arraysize(kTestFields); ++i) 268 form_structure->field(i)->set_server_type(kTestFields[i].autofill_type); 269 270 return form_structure.Pass(); 271 } 272 273 class MockAutofillManagerDelegate : public TestAutofillManagerDelegate { 274 public: 275 MockAutofillManagerDelegate() 276 : request_autocomplete_dialog_open_(false), 277 autocheckout_bubble_shown_(false), 278 should_autoclick_bubble_(true) {} 279 280 virtual ~MockAutofillManagerDelegate() {} 281 282 virtual void HideRequestAutocompleteDialog() OVERRIDE { 283 request_autocomplete_dialog_open_ = false; 284 } 285 286 MOCK_METHOD0(OnAutocheckoutError, void()); 287 MOCK_METHOD0(OnAutocheckoutSuccess, void()); 288 289 virtual bool ShowAutocheckoutBubble( 290 const gfx::RectF& bounds, 291 bool is_google_user, 292 const base::Callback<void(AutocheckoutBubbleState)>& callback) OVERRIDE { 293 autocheckout_bubble_shown_ = true; 294 if (should_autoclick_bubble_) 295 callback.Run(AUTOCHECKOUT_BUBBLE_ACCEPTED); 296 return true; 297 } 298 299 virtual void ShowRequestAutocompleteDialog( 300 const FormData& form, 301 const GURL& source_url, 302 DialogType dialog_type, 303 const base::Callback<void(const FormStructure*, 304 const std::string&)>& callback) OVERRIDE { 305 request_autocomplete_dialog_open_ = true; 306 callback.Run(user_supplied_data_.get(), "google_transaction_id"); 307 } 308 309 virtual void AddAutocheckoutStep(AutocheckoutStepType step_type) OVERRIDE { 310 if (autocheckout_steps_.count(step_type) == 0) 311 autocheckout_steps_[step_type] = AUTOCHECKOUT_STEP_UNSTARTED; 312 } 313 314 virtual void UpdateAutocheckoutStep( 315 AutocheckoutStepType step_type, 316 AutocheckoutStepStatus step_status) OVERRIDE { 317 autocheckout_steps_[step_type] = step_status; 318 } 319 320 void SetUserSuppliedData(scoped_ptr<FormStructure> user_supplied_data) { 321 user_supplied_data_.reset(user_supplied_data.release()); 322 } 323 324 bool autocheckout_bubble_shown() const { 325 return autocheckout_bubble_shown_; 326 } 327 328 void set_autocheckout_bubble_shown(bool autocheckout_bubble_shown) { 329 autocheckout_bubble_shown_ = autocheckout_bubble_shown; 330 } 331 332 bool request_autocomplete_dialog_open() const { 333 return request_autocomplete_dialog_open_; 334 } 335 336 void set_should_autoclick_bubble(bool should_autoclick_bubble) { 337 should_autoclick_bubble_ = should_autoclick_bubble; 338 } 339 340 bool AutocheckoutStepExistsWithStatus( 341 AutocheckoutStepType step_type, 342 AutocheckoutStepStatus step_status) const { 343 std::map<AutocheckoutStepType, AutocheckoutStepStatus>::const_iterator it = 344 autocheckout_steps_.find(step_type); 345 return it != autocheckout_steps_.end() && it->second == step_status; 346 } 347 348 private: 349 // Whether or not ShowRequestAutocompleteDialog method has been called. 350 bool request_autocomplete_dialog_open_; 351 352 // Whether or not Autocheckout bubble is displayed to user. 353 bool autocheckout_bubble_shown_; 354 355 // Whether or not to accept the Autocheckout bubble when offered. 356 bool should_autoclick_bubble_; 357 358 // User specified data that would be returned to AutocheckoutManager when 359 // dialog is accepted. 360 scoped_ptr<FormStructure> user_supplied_data_; 361 362 // Step status of various Autocheckout steps in this checkout flow. 363 std::map<AutocheckoutStepType, AutocheckoutStepStatus> autocheckout_steps_; 364 }; 365 366 class TestAutofillManager : public AutofillManager { 367 public: 368 explicit TestAutofillManager(AutofillDriver* driver, 369 AutofillManagerDelegate* delegate) 370 : AutofillManager(driver, delegate, NULL) { 371 } 372 virtual ~TestAutofillManager() {} 373 374 void SetFormStructure(scoped_ptr<FormStructure> form_structure) { 375 form_structures()->clear(); 376 form_structures()->push_back(form_structure.release()); 377 } 378 }; 379 380 class MockAutofillMetrics : public AutofillMetrics { 381 public: 382 MockAutofillMetrics() {} 383 MOCK_CONST_METHOD1(LogAutocheckoutBubbleMetric, void(BubbleMetric)); 384 MOCK_CONST_METHOD1(LogAutocheckoutBuyFlowMetric, 385 void(AutocheckoutBuyFlowMetric)); 386 387 private: 388 DISALLOW_COPY_AND_ASSIGN(MockAutofillMetrics); 389 }; 390 391 class TestAutocheckoutManager: public AutocheckoutManager { 392 public: 393 explicit TestAutocheckoutManager(AutofillManager* autofill_manager) 394 : AutocheckoutManager(autofill_manager) { 395 set_metric_logger(scoped_ptr<AutofillMetrics>(new MockAutofillMetrics)); 396 } 397 398 const MockAutofillMetrics& metric_logger() const { 399 return static_cast<const MockAutofillMetrics&>( 400 AutocheckoutManager::metric_logger()); 401 } 402 403 virtual void MaybeShowAutocheckoutBubble( 404 const GURL& frame_url, 405 const gfx::RectF& bounding_box) OVERRIDE { 406 AutocheckoutManager::MaybeShowAutocheckoutBubble(frame_url, 407 bounding_box); 408 // Needed for AutocheckoutManager to post task on IO thread. 409 content::RunAllPendingInMessageLoop(BrowserThread::IO); 410 } 411 412 using AutocheckoutManager::in_autocheckout_flow; 413 using AutocheckoutManager::should_show_bubble; 414 using AutocheckoutManager::MaybeShowAutocheckoutDialog; 415 using AutocheckoutManager::ReturnAutocheckoutData; 416 }; 417 418 } // namespace 419 420 class AutocheckoutManagerTest : public ChromeRenderViewHostTestHarness { 421 protected: 422 virtual void SetUp() OVERRIDE { 423 SetThreadBundleOptions(content::TestBrowserThreadBundle::REAL_IO_THREAD); 424 ChromeRenderViewHostTestHarness::SetUp(); 425 autofill_manager_delegate_.reset(new MockAutofillManagerDelegate()); 426 autofill_driver_.reset(new TestAutofillDriver(web_contents())); 427 autofill_manager_.reset(new TestAutofillManager( 428 autofill_driver_.get(), 429 autofill_manager_delegate_.get())); 430 autocheckout_manager_.reset( 431 new TestAutocheckoutManager(autofill_manager_.get())); 432 } 433 434 virtual void TearDown() OVERRIDE { 435 autocheckout_manager_.reset(); 436 autofill_manager_delegate_.reset(); 437 autofill_manager_.reset(); 438 autofill_driver_.reset(); 439 ChromeRenderViewHostTestHarness::TearDown(); 440 } 441 442 std::vector<FormData> ReadFilledForms() { 443 uint32 kMsgID = AutofillMsg_FillFormsAndClick::ID; 444 const IPC::Message* message = 445 process()->sink().GetFirstMessageMatching(kMsgID); 446 AutofillParam autofill_param; 447 AutofillMsg_FillFormsAndClick::Read(message, &autofill_param); 448 return autofill_param.a; 449 } 450 451 void CheckFillFormsAndClickIpc( 452 ProceedElementPresence proceed_element_presence) { 453 EXPECT_EQ(1U, process()->sink().message_count()); 454 uint32 kMsgID = AutofillMsg_FillFormsAndClick::ID; 455 const IPC::Message* message = 456 process()->sink().GetFirstMessageMatching(kMsgID); 457 EXPECT_TRUE(message); 458 AutofillParam autofill_param; 459 AutofillMsg_FillFormsAndClick::Read(message, &autofill_param); 460 if (proceed_element_presence == HAS_PROCEED_ELEMENT) { 461 EXPECT_EQ(WebElementDescriptor::ID, autofill_param.d.retrieval_method); 462 EXPECT_EQ("#foo", autofill_param.d.descriptor); 463 } else { 464 EXPECT_EQ(WebElementDescriptor::NONE, autofill_param.d.retrieval_method); 465 } 466 ClearIpcSink(); 467 } 468 469 void ClearIpcSink() { 470 process()->sink().ClearMessages(); 471 } 472 473 void OpenRequestAutocompleteDialog() { 474 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 475 EXPECT_FALSE( 476 autofill_manager_delegate_->request_autocomplete_dialog_open()); 477 EXPECT_CALL(autocheckout_manager_->metric_logger(), 478 LogAutocheckoutBubbleMetric( 479 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 480 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 481 // Simulate the user submitting some data via the requestAutocomplete UI. 482 autofill_manager_delegate_->SetUserSuppliedData( 483 FakeUserSubmittedFormStructure()); 484 GURL frame_url; 485 EXPECT_CALL(autocheckout_manager_->metric_logger(), 486 LogAutocheckoutBuyFlowMetric( 487 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_STARTED)).Times(1); 488 autocheckout_manager_->MaybeShowAutocheckoutDialog( 489 frame_url, 490 AUTOCHECKOUT_BUBBLE_ACCEPTED); 491 CheckFillFormsAndClickIpc(HAS_PROCEED_ELEMENT); 492 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 493 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 494 EXPECT_TRUE(autofill_manager_delegate_->request_autocomplete_dialog_open()); 495 EXPECT_TRUE(autofill_manager_delegate_ 496 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 497 AUTOCHECKOUT_STEP_STARTED)); 498 EXPECT_TRUE(autofill_manager_delegate_ 499 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 500 AUTOCHECKOUT_STEP_UNSTARTED)); 501 EXPECT_TRUE(autofill_manager_delegate_ 502 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_BILLING, 503 AUTOCHECKOUT_STEP_UNSTARTED)); 504 } 505 506 void HideRequestAutocompleteDialog() { 507 EXPECT_TRUE( 508 autofill_manager_delegate_->request_autocomplete_dialog_open()); 509 autofill_manager_delegate_->HideRequestAutocompleteDialog(); 510 EXPECT_FALSE( 511 autofill_manager_delegate_->request_autocomplete_dialog_open()); 512 } 513 514 // Test a multi-page Autocheckout flow end to end. 515 // |proceed_element_presence_on_last_page| indicates whether the last page 516 // of the flow should have a proceed element. 517 void TestFullAutocheckoutFlow( 518 ProceedElementPresence proceed_element_presence_on_last_page) { 519 // Test for progression through last page. 520 OpenRequestAutocompleteDialog(); 521 EXPECT_TRUE(autofill_manager_delegate_ 522 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 523 AUTOCHECKOUT_STEP_STARTED)); 524 // Complete the first page. 525 autocheckout_manager_->OnAutocheckoutPageCompleted(SUCCESS); 526 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 527 EXPECT_TRUE(autofill_manager_delegate_ 528 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 529 AUTOCHECKOUT_STEP_COMPLETED)); 530 531 // Go to the second page. 532 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutSuccess()).Times(1); 533 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 534 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 535 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 536 CheckFillFormsAndClickIpc(HAS_PROCEED_ELEMENT); 537 EXPECT_TRUE(autofill_manager_delegate_ 538 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 539 AUTOCHECKOUT_STEP_STARTED)); 540 autocheckout_manager_->OnAutocheckoutPageCompleted(SUCCESS); 541 EXPECT_TRUE(autofill_manager_delegate_ 542 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 543 AUTOCHECKOUT_STEP_COMPLETED)); 544 545 // Go to the third page. 546 EXPECT_CALL(autocheckout_manager_->metric_logger(), 547 LogAutocheckoutBuyFlowMetric( 548 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_SUCCESS)).Times(1); 549 autocheckout_manager_->OnLoadedPageMetaData( 550 CreateEndOfFlowMetaData(proceed_element_presence_on_last_page)); 551 CheckFillFormsAndClickIpc(proceed_element_presence_on_last_page); 552 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 553 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 554 EXPECT_TRUE(autofill_manager_delegate_ 555 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_BILLING, 556 AUTOCHECKOUT_STEP_STARTED)); 557 autocheckout_manager_->OnAutocheckoutPageCompleted(SUCCESS); 558 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 559 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 560 EXPECT_TRUE(autofill_manager_delegate_ 561 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_BILLING, 562 AUTOCHECKOUT_STEP_COMPLETED)); 563 564 EXPECT_TRUE(autofill_manager_delegate_->request_autocomplete_dialog_open()); 565 566 // Go to the page after the flow. 567 autocheckout_manager_->OnLoadedPageMetaData( 568 scoped_ptr<AutocheckoutPageMetaData>()); 569 EXPECT_EQ(proceed_element_presence_on_last_page == HAS_PROCEED_ELEMENT, 570 autocheckout_manager_->should_preserve_dialog()); 571 // Go to another page and we should not preserve the dialog now. 572 autocheckout_manager_->OnLoadedPageMetaData( 573 scoped_ptr<AutocheckoutPageMetaData>()); 574 EXPECT_FALSE(autocheckout_manager_->should_preserve_dialog()); 575 } 576 577 // Test a signle-page Autocheckout flow. |proceed_element_presence| indicates 578 // whether the page should have a proceed element. 579 void TestSinglePageFlow(ProceedElementPresence proceed_element_presence) { 580 // Test one page flow. 581 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 582 EXPECT_FALSE( 583 autofill_manager_delegate_->request_autocomplete_dialog_open()); 584 EXPECT_CALL(autocheckout_manager_->metric_logger(), 585 LogAutocheckoutBubbleMetric( 586 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 587 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutSuccess()).Times(1); 588 autocheckout_manager_->OnLoadedPageMetaData( 589 CreateOnePageFlowMetaData(proceed_element_presence)); 590 // Simulate the user submitting some data via the requestAutocomplete UI. 591 autofill_manager_delegate_->SetUserSuppliedData( 592 FakeUserSubmittedFormStructure()); 593 GURL frame_url; 594 EXPECT_CALL(autocheckout_manager_->metric_logger(), 595 LogAutocheckoutBuyFlowMetric( 596 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_STARTED)).Times(1); 597 EXPECT_CALL(autocheckout_manager_->metric_logger(), 598 LogAutocheckoutBuyFlowMetric( 599 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_SUCCESS)).Times(1); 600 autocheckout_manager_->MaybeShowAutocheckoutDialog( 601 frame_url, 602 AUTOCHECKOUT_BUBBLE_ACCEPTED); 603 autocheckout_manager_->OnAutocheckoutPageCompleted(SUCCESS); 604 CheckFillFormsAndClickIpc(proceed_element_presence); 605 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 606 EXPECT_TRUE(autocheckout_manager_->should_preserve_dialog()); 607 EXPECT_TRUE(autofill_manager_delegate_->request_autocomplete_dialog_open()); 608 EXPECT_TRUE(autofill_manager_delegate_ 609 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 610 AUTOCHECKOUT_STEP_COMPLETED)); 611 EXPECT_TRUE(autofill_manager_delegate_ 612 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 613 AUTOCHECKOUT_STEP_COMPLETED)); 614 EXPECT_TRUE(autofill_manager_delegate_ 615 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_BILLING, 616 AUTOCHECKOUT_STEP_COMPLETED)); 617 // Go to the page after the flow. 618 autocheckout_manager_->OnLoadedPageMetaData( 619 scoped_ptr<AutocheckoutPageMetaData>()); 620 EXPECT_EQ(proceed_element_presence == HAS_PROCEED_ELEMENT, 621 autocheckout_manager_->should_preserve_dialog()); 622 // Go to another page, and we should not preserve the dialog now. 623 autocheckout_manager_->OnLoadedPageMetaData( 624 scoped_ptr<AutocheckoutPageMetaData>()); 625 EXPECT_FALSE(autocheckout_manager_->should_preserve_dialog()); 626 } 627 628 protected: 629 scoped_ptr<TestAutofillDriver> autofill_driver_; 630 scoped_ptr<TestAutofillManager> autofill_manager_; 631 scoped_ptr<TestAutocheckoutManager> autocheckout_manager_; 632 scoped_ptr<MockAutofillManagerDelegate> autofill_manager_delegate_; 633 }; 634 635 TEST_F(AutocheckoutManagerTest, TestFillForms) { 636 OpenRequestAutocompleteDialog(); 637 638 // Test if autocheckout manager can fill the first page. 639 autofill_manager_->SetFormStructure(CreateTestAddressFormStructure()); 640 641 autocheckout_manager_->FillForms(); 642 643 std::vector<FormData> filled_forms = ReadFilledForms(); 644 ASSERT_EQ(1U, filled_forms.size()); 645 ASSERT_EQ(9U, filled_forms[0].fields.size()); 646 EXPECT_EQ(ASCIIToUTF16("Test User"), filled_forms[0].fields[0].value); 647 EXPECT_EQ(ASCIIToUTF16("650-123-9909"), filled_forms[0].fields[1].value); 648 EXPECT_EQ(ASCIIToUTF16("blah (at) blah.com"), filled_forms[0].fields[2].value); 649 EXPECT_EQ(ASCIIToUTF16("Fake Street"), filled_forms[0].fields[3].value); 650 EXPECT_EQ(ASCIIToUTF16("Mocked City"), filled_forms[0].fields[4].value); 651 EXPECT_EQ(ASCIIToUTF16("California"), filled_forms[0].fields[5].value); 652 EXPECT_EQ(ASCIIToUTF16("United States"), filled_forms[0].fields[6].value); 653 EXPECT_EQ(ASCIIToUTF16("49012"), filled_forms[0].fields[7].value); 654 // Last field should not be filled, because there is no server mapping 655 // available for it. 656 EXPECT_EQ(ASCIIToUTF16("SomeField"), filled_forms[0].fields[8].value); 657 658 filled_forms.clear(); 659 ClearIpcSink(); 660 661 // Test if autocheckout manager can fill form on second page. 662 autofill_manager_->SetFormStructure(CreateTestCreditCardFormStructure()); 663 664 autocheckout_manager_->FillForms(); 665 666 filled_forms = ReadFilledForms(); 667 ASSERT_EQ(1U, filled_forms.size()); 668 ASSERT_EQ(10U, filled_forms[0].fields.size()); 669 EXPECT_EQ(ASCIIToUTF16("Test User"), filled_forms[0].fields[0].value); 670 EXPECT_EQ(ASCIIToUTF16("4444444444444448"), filled_forms[0].fields[1].value); 671 EXPECT_EQ(ASCIIToUTF16("10"), filled_forms[0].fields[2].value); 672 EXPECT_EQ(ASCIIToUTF16("2020"), filled_forms[0].fields[3].value); 673 EXPECT_EQ(ASCIIToUTF16("123"), filled_forms[0].fields[4].value); 674 EXPECT_EQ(ASCIIToUTF16("Billing Street"), filled_forms[0].fields[5].value); 675 EXPECT_EQ(ASCIIToUTF16("Billing City"), filled_forms[0].fields[6].value); 676 EXPECT_EQ(ASCIIToUTF16("BillingState"), filled_forms[0].fields[7].value); 677 EXPECT_EQ(ASCIIToUTF16("Canada"), filled_forms[0].fields[8].value); 678 EXPECT_EQ(ASCIIToUTF16("11111"), filled_forms[0].fields[9].value); 679 680 filled_forms.clear(); 681 ClearIpcSink(); 682 683 // Test form with default values. 684 autofill_manager_->SetFormStructure( 685 CreateTestFormStructureWithDefaultValues()); 686 687 autocheckout_manager_->FillForms(); 688 689 filled_forms = ReadFilledForms(); 690 ASSERT_EQ(1U, filled_forms.size()); 691 ASSERT_EQ(3U, filled_forms[0].fields.size()); 692 EXPECT_FALSE(filled_forms[0].fields[0].is_checked); 693 EXPECT_EQ(ASCIIToUTF16("male"), filled_forms[0].fields[0].value); 694 EXPECT_TRUE(filled_forms[0].fields[1].is_checked); 695 EXPECT_EQ(ASCIIToUTF16("female"), filled_forms[0].fields[1].value); 696 EXPECT_EQ(ASCIIToUTF16("Default Value"), filled_forms[0].fields[2].value); 697 } 698 699 TEST_F(AutocheckoutManagerTest, OnFormsSeenTest) { 700 GURL frame_url; 701 gfx::RectF bounding_box; 702 EXPECT_CALL(autocheckout_manager_->metric_logger(), 703 LogAutocheckoutBubbleMetric( 704 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 705 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 706 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 707 708 EXPECT_FALSE(autocheckout_manager_->should_show_bubble()); 709 // OnFormsSeen resets whether or not the bubble was shown. 710 autocheckout_manager_->OnFormsSeen(); 711 EXPECT_TRUE(autocheckout_manager_->should_show_bubble()); 712 } 713 714 TEST_F(AutocheckoutManagerTest, OnClickFailedTestMissingAdvance) { 715 OpenRequestAutocompleteDialog(); 716 717 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 718 EXPECT_CALL( 719 autocheckout_manager_->metric_logger(), 720 LogAutocheckoutBuyFlowMetric( 721 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_MISSING_ADVANCE_ELEMENT)) 722 .Times(1); 723 autocheckout_manager_->OnAutocheckoutPageCompleted(MISSING_ADVANCE); 724 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 725 EXPECT_TRUE( 726 autofill_manager_delegate_->request_autocomplete_dialog_open()); 727 EXPECT_TRUE(autofill_manager_delegate_ 728 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 729 AUTOCHECKOUT_STEP_FAILED)); 730 } 731 732 TEST_F(AutocheckoutManagerTest, OnClickFailedTestMissingClickBeforeFilling) { 733 OpenRequestAutocompleteDialog(); 734 735 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 736 EXPECT_CALL( 737 autocheckout_manager_->metric_logger(), 738 LogAutocheckoutBuyFlowMetric(AutofillMetrics:: 739 AUTOCHECKOUT_BUY_FLOW_MISSING_CLICK_ELEMENT_BEFORE_FORM_FILLING)) 740 .Times(1); 741 autocheckout_manager_->OnAutocheckoutPageCompleted( 742 MISSING_CLICK_ELEMENT_BEFORE_FORM_FILLING); 743 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 744 EXPECT_TRUE( 745 autofill_manager_delegate_->request_autocomplete_dialog_open()); 746 } 747 748 TEST_F(AutocheckoutManagerTest, OnClickFailedTestMissingClickAfterFilling) { 749 OpenRequestAutocompleteDialog(); 750 751 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 752 EXPECT_CALL( 753 autocheckout_manager_->metric_logger(), 754 LogAutocheckoutBuyFlowMetric(AutofillMetrics:: 755 AUTOCHECKOUT_BUY_FLOW_MISSING_CLICK_ELEMENT_AFTER_FORM_FILLING)) 756 .Times(1); 757 autocheckout_manager_->OnAutocheckoutPageCompleted( 758 MISSING_CLICK_ELEMENT_AFTER_FORM_FILLING); 759 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 760 EXPECT_TRUE( 761 autofill_manager_delegate_->request_autocomplete_dialog_open()); 762 } 763 764 TEST_F(AutocheckoutManagerTest, MaybeShowAutocheckoutBubbleTest) { 765 GURL frame_url; 766 gfx::RectF bounding_box; 767 EXPECT_CALL(autocheckout_manager_->metric_logger(), 768 LogAutocheckoutBubbleMetric( 769 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 770 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 771 // MaybeShowAutocheckoutBubble shows bubble if it has not been shown. 772 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 773 EXPECT_FALSE(autocheckout_manager_->should_show_bubble()); 774 EXPECT_TRUE(autofill_manager_delegate_->autocheckout_bubble_shown()); 775 776 // Reset |autofill_manager_delegate_|. 777 HideRequestAutocompleteDialog(); 778 autofill_manager_delegate_->set_autocheckout_bubble_shown(false); 779 780 // MaybeShowAutocheckoutBubble does nothing if the bubble was already shown 781 // for the current page. 782 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 783 EXPECT_FALSE(autocheckout_manager_->should_show_bubble()); 784 EXPECT_FALSE(autofill_manager_delegate_->autocheckout_bubble_shown()); 785 EXPECT_FALSE(autofill_manager_delegate_->request_autocomplete_dialog_open()); 786 } 787 788 TEST_F(AutocheckoutManagerTest, OnLoadedPageMetaDataMissingMetaData) { 789 // Gettting no meta data after any autocheckout page is an error. 790 OpenRequestAutocompleteDialog(); 791 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 792 EXPECT_CALL( 793 autocheckout_manager_->metric_logger(), 794 LogAutocheckoutBuyFlowMetric( 795 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_MISSING_FIELDMAPPING)) 796 .Times(1); 797 autocheckout_manager_->OnLoadedPageMetaData( 798 scoped_ptr<AutocheckoutPageMetaData>()); 799 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 800 EXPECT_EQ(0U, process()->sink().message_count()); 801 EXPECT_TRUE( 802 autofill_manager_delegate_->request_autocomplete_dialog_open()); 803 } 804 805 TEST_F(AutocheckoutManagerTest, OnLoadedPageMetaDataRepeatedStartPage) { 806 // Getting start page twice in a row is an error. 807 OpenRequestAutocompleteDialog(); 808 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 809 EXPECT_CALL( 810 autocheckout_manager_->metric_logger(), 811 LogAutocheckoutBuyFlowMetric( 812 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_CANNOT_PROCEED)).Times(1); 813 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 814 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 815 EXPECT_EQ(0U, process()->sink().message_count()); 816 EXPECT_TRUE( 817 autofill_manager_delegate_->request_autocomplete_dialog_open()); 818 819 EXPECT_TRUE(autofill_manager_delegate_ 820 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_SHIPPING, 821 AUTOCHECKOUT_STEP_FAILED)); 822 } 823 824 TEST_F(AutocheckoutManagerTest, OnLoadedPageMetaDataRepeatedPage) { 825 // Repeating a page is an error. 826 OpenRequestAutocompleteDialog(); 827 // Go to second page. 828 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 829 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 830 CheckFillFormsAndClickIpc(HAS_PROCEED_ELEMENT); 831 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 832 EXPECT_CALL( 833 autocheckout_manager_->metric_logger(), 834 LogAutocheckoutBuyFlowMetric( 835 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_CANNOT_PROCEED)).Times(1); 836 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 837 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 838 EXPECT_EQ(0U, process()->sink().message_count()); 839 EXPECT_TRUE( 840 autofill_manager_delegate_->request_autocomplete_dialog_open()); 841 EXPECT_TRUE(autofill_manager_delegate_ 842 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 843 AUTOCHECKOUT_STEP_FAILED)); 844 } 845 846 TEST_F(AutocheckoutManagerTest, OnLoadedPageMetaDataNotInFlow) { 847 // Repeating a page is an error. 848 OpenRequestAutocompleteDialog(); 849 // Go to second page. 850 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 851 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 852 CheckFillFormsAndClickIpc(HAS_PROCEED_ELEMENT); 853 EXPECT_CALL(*autofill_manager_delegate_, OnAutocheckoutError()).Times(1); 854 EXPECT_CALL( 855 autocheckout_manager_->metric_logger(), 856 LogAutocheckoutBuyFlowMetric( 857 AutofillMetrics::AUTOCHECKOUT_BUY_FLOW_MISSING_FIELDMAPPING)) 858 .Times(1); 859 autocheckout_manager_->OnLoadedPageMetaData(CreateNotInFlowMetaData()); 860 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 861 EXPECT_EQ(0U, process()->sink().message_count()); 862 EXPECT_TRUE( 863 autofill_manager_delegate_->request_autocomplete_dialog_open()); 864 EXPECT_TRUE(autofill_manager_delegate_ 865 ->AutocheckoutStepExistsWithStatus(AUTOCHECKOUT_STEP_DELIVERY, 866 AUTOCHECKOUT_STEP_FAILED)); 867 } 868 869 TEST_F(AutocheckoutManagerTest, 870 OnLoadedPageMetaDataShouldNotFillFormsIfNotInFlow) { 871 // If not in flow, OnLoadedPageMetaData does not fill forms. 872 EXPECT_CALL(autocheckout_manager_->metric_logger(), 873 LogAutocheckoutBubbleMetric( 874 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 875 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 876 // Go to second page. 877 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 878 EXPECT_EQ(0U, process()->sink().message_count()); 879 } 880 881 TEST_F(AutocheckoutManagerTest, FullAutocheckoutFlow) { 882 TestFullAutocheckoutFlow(HAS_PROCEED_ELEMENT); 883 } 884 885 TEST_F(AutocheckoutManagerTest, FullAutocheckoutFlowNoClickOnLastPage) { 886 TestFullAutocheckoutFlow(NO_PROCEED_ELEMENT); 887 } 888 889 TEST_F(AutocheckoutManagerTest, CancelledAutocheckoutFlow) { 890 // Test for progression through last page. 891 OpenRequestAutocompleteDialog(); 892 // Go to second page. 893 autocheckout_manager_->OnLoadedPageMetaData(CreateInFlowMetaData()); 894 EXPECT_TRUE(autocheckout_manager_->in_autocheckout_flow()); 895 CheckFillFormsAndClickIpc(HAS_PROCEED_ELEMENT); 896 897 // Cancel the flow. 898 autocheckout_manager_->ReturnAutocheckoutData(NULL, std::string()); 899 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 900 901 // Go to third page. 902 EXPECT_CALL(autocheckout_manager_->metric_logger(), 903 LogAutocheckoutBuyFlowMetric(testing::_)).Times(0); 904 autocheckout_manager_->OnLoadedPageMetaData( 905 CreateEndOfFlowMetaData(HAS_PROCEED_ELEMENT)); 906 EXPECT_EQ(0U, process()->sink().message_count()); 907 } 908 909 TEST_F(AutocheckoutManagerTest, SinglePageFlow) { 910 TestSinglePageFlow(HAS_PROCEED_ELEMENT); 911 } 912 913 TEST_F(AutocheckoutManagerTest, SinglePageFlowNoClickElement) { 914 TestSinglePageFlow(NO_PROCEED_ELEMENT); 915 } 916 917 TEST_F(AutocheckoutManagerTest, CancelAutocheckoutBubble) { 918 GURL frame_url; 919 gfx::RectF bounding_box; 920 autofill_manager_delegate_->set_should_autoclick_bubble(false); 921 EXPECT_FALSE(autocheckout_manager_->in_autocheckout_flow()); 922 EXPECT_FALSE(autofill_manager_delegate_->request_autocomplete_dialog_open()); 923 EXPECT_FALSE(autocheckout_manager_->is_autocheckout_bubble_showing()); 924 EXPECT_CALL(autocheckout_manager_->metric_logger(), 925 LogAutocheckoutBubbleMetric( 926 AutofillMetrics::BUBBLE_COULD_BE_DISPLAYED)).Times(1); 927 autocheckout_manager_->OnLoadedPageMetaData(CreateStartOfFlowMetaData()); 928 929 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 930 EXPECT_TRUE(autocheckout_manager_->is_autocheckout_bubble_showing()); 931 autocheckout_manager_->MaybeShowAutocheckoutDialog( 932 frame_url, 933 AUTOCHECKOUT_BUBBLE_IGNORED); 934 EXPECT_FALSE(autocheckout_manager_->is_autocheckout_bubble_showing()); 935 EXPECT_TRUE(autocheckout_manager_->should_show_bubble()); 936 937 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 938 EXPECT_TRUE(autocheckout_manager_->is_autocheckout_bubble_showing()); 939 autocheckout_manager_->MaybeShowAutocheckoutDialog( 940 frame_url, 941 AUTOCHECKOUT_BUBBLE_CANCELED); 942 EXPECT_FALSE(autocheckout_manager_->is_autocheckout_bubble_showing()); 943 EXPECT_FALSE(autocheckout_manager_->should_show_bubble()); 944 945 autocheckout_manager_->MaybeShowAutocheckoutBubble(frame_url, bounding_box); 946 EXPECT_FALSE(autocheckout_manager_->is_autocheckout_bubble_showing()); 947 } 948 949 } // namespace autofill 950
