autofill_metrics_unittest.cc revision 0f1bc08d4cfcc34181b0b5cbf065c40f687bf740
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 "components/autofill/core/browser/autofill_metrics.h" 6 7#include <vector> 8 9#include "base/memory/ref_counted.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/strings/string16.h" 12#include "base/strings/utf_string_conversions.h" 13#include "base/time/time.h" 14#include "chrome/browser/autofill/autofill_cc_infobar_delegate.h" 15#include "chrome/browser/autofill/personal_data_manager_factory.h" 16#include "chrome/browser/ui/autofill/tab_autofill_manager_delegate.h" 17#include "chrome/test/base/chrome_render_view_host_test_harness.h" 18#include "chrome/test/base/testing_profile.h" 19#include "components/autofill/core/browser/autofill_common_test.h" 20#include "components/autofill/core/browser/autofill_external_delegate.h" 21#include "components/autofill/core/browser/autofill_manager.h" 22#include "components/autofill/core/browser/autofill_manager_delegate.h" 23#include "components/autofill/core/browser/personal_data_manager.h" 24#include "components/autofill/core/browser/test_autofill_driver.h" 25#include "components/autofill/core/common/form_data.h" 26#include "components/autofill/core/common/form_field_data.h" 27#include "components/autofill/core/common/forms_seen_state.h" 28#include "components/webdata/common/web_data_results.h" 29#include "content/public/test/test_utils.h" 30#include "testing/gmock/include/gmock/gmock.h" 31#include "testing/gtest/include/gtest/gtest.h" 32#include "ui/gfx/rect.h" 33#include "url/gurl.h" 34 35using base::TimeDelta; 36using base::TimeTicks; 37using testing::_; 38using testing::AnyNumber; 39using testing::Mock; 40 41namespace autofill { 42 43namespace { 44 45class MockAutofillMetrics : public AutofillMetrics { 46 public: 47 MockAutofillMetrics() {} 48 MOCK_CONST_METHOD1(LogCreditCardInfoBarMetric, void(InfoBarMetric metric)); 49 MOCK_CONST_METHOD1(LogDeveloperEngagementMetric, 50 void(DeveloperEngagementMetric metric)); 51 MOCK_CONST_METHOD3(LogHeuristicTypePrediction, 52 void(FieldTypeQualityMetric metric, 53 ServerFieldType field_type, 54 const std::string& experiment_id)); 55 MOCK_CONST_METHOD3(LogOverallTypePrediction, 56 void(FieldTypeQualityMetric metric, 57 ServerFieldType field_type, 58 const std::string& experiment_id)); 59 MOCK_CONST_METHOD3(LogServerTypePrediction, 60 void(FieldTypeQualityMetric metric, 61 ServerFieldType field_type, 62 const std::string& experiment_id)); 63 MOCK_CONST_METHOD2(LogQualityMetric, void(QualityMetric metric, 64 const std::string& experiment_id)); 65 MOCK_CONST_METHOD1(LogServerQueryMetric, void(ServerQueryMetric metric)); 66 MOCK_CONST_METHOD1(LogUserHappinessMetric, void(UserHappinessMetric metric)); 67 MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithAutofill, 68 void(const TimeDelta& duration)); 69 MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithoutAutofill, 70 void(const TimeDelta& duration)); 71 MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithAutofill, 72 void(const TimeDelta& duration)); 73 MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithoutAutofill, 74 void(const TimeDelta& duration)); 75 MOCK_CONST_METHOD1(LogIsAutofillEnabledAtPageLoad, void(bool enabled)); 76 MOCK_CONST_METHOD1(LogIsAutofillEnabledAtStartup, void(bool enabled)); 77 MOCK_CONST_METHOD1(LogStoredProfileCount, void(size_t num_profiles)); 78 MOCK_CONST_METHOD1(LogAddressSuggestionsCount, void(size_t num_suggestions)); 79 MOCK_CONST_METHOD1(LogServerExperimentIdForQuery, 80 void(const std::string& experiment_id)); 81 MOCK_CONST_METHOD1(LogServerExperimentIdForUpload, 82 void(const std::string& experiment_id)); 83 84 private: 85 DISALLOW_COPY_AND_ASSIGN(MockAutofillMetrics); 86}; 87 88class TestPersonalDataManager : public PersonalDataManager { 89 public: 90 TestPersonalDataManager() 91 : PersonalDataManager("en-US"), 92 autofill_enabled_(true) { 93 set_metric_logger(new testing::NiceMock<MockAutofillMetrics>()); 94 CreateTestAutofillProfiles(&web_profiles_); 95 } 96 97 void SetBrowserContext(content::BrowserContext* context) { 98 set_browser_context(context); 99 } 100 101 void SetPrefService(PrefService* pref_service) { 102 set_pref_service(pref_service); 103 } 104 105 // Overridden to avoid a trip to the database. This should be a no-op except 106 // for the side-effect of logging the profile count. 107 virtual void LoadProfiles() OVERRIDE { 108 std::vector<AutofillProfile*> profiles; 109 web_profiles_.release(&profiles); 110 WDResult<std::vector<AutofillProfile*> > result(AUTOFILL_PROFILES_RESULT, 111 profiles); 112 ReceiveLoadedProfiles(0, &result); 113 } 114 115 // Overridden to avoid a trip to the database. 116 virtual void LoadCreditCards() OVERRIDE {} 117 118 const MockAutofillMetrics* metric_logger() const { 119 return static_cast<const MockAutofillMetrics*>( 120 PersonalDataManager::metric_logger()); 121 } 122 123 void set_autofill_enabled(bool autofill_enabled) { 124 autofill_enabled_ = autofill_enabled; 125 } 126 127 virtual bool IsAutofillEnabled() const OVERRIDE { 128 return autofill_enabled_; 129 } 130 131 MOCK_METHOD1(SaveImportedCreditCard, 132 std::string(const CreditCard& imported_credit_card)); 133 134 private: 135 void CreateTestAutofillProfiles(ScopedVector<AutofillProfile>* profiles) { 136 AutofillProfile* profile = new AutofillProfile; 137 test::SetProfileInfo(profile, "Elvis", "Aaron", 138 "Presley", "theking@gmail.com", "RCA", 139 "3734 Elvis Presley Blvd.", "Apt. 10", 140 "Memphis", "Tennessee", "38116", "US", 141 "12345678901"); 142 profile->set_guid("00000000-0000-0000-0000-000000000001"); 143 profiles->push_back(profile); 144 profile = new AutofillProfile; 145 test::SetProfileInfo(profile, "Charles", "Hardin", 146 "Holley", "buddy@gmail.com", "Decca", 147 "123 Apple St.", "unit 6", "Lubbock", 148 "Texas", "79401", "US", "2345678901"); 149 profile->set_guid("00000000-0000-0000-0000-000000000002"); 150 profiles->push_back(profile); 151 } 152 153 bool autofill_enabled_; 154 155 DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager); 156}; 157 158class TestFormStructure : public FormStructure { 159 public: 160 explicit TestFormStructure(const FormData& form) : FormStructure(form) {} 161 virtual ~TestFormStructure() {} 162 163 void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types, 164 const std::vector<ServerFieldType>& server_types) { 165 ASSERT_EQ(field_count(), heuristic_types.size()); 166 ASSERT_EQ(field_count(), server_types.size()); 167 168 for (size_t i = 0; i < field_count(); ++i) { 169 AutofillField* form_field = field(i); 170 ASSERT_TRUE(form_field); 171 form_field->set_heuristic_type(heuristic_types[i]); 172 form_field->set_server_type(server_types[i]); 173 } 174 175 UpdateAutofillCount(); 176 } 177 178 virtual std::string server_experiment_id() const OVERRIDE { 179 return server_experiment_id_; 180 } 181 void set_server_experiment_id(const std::string& server_experiment_id) { 182 server_experiment_id_ = server_experiment_id; 183 } 184 185 private: 186 std::string server_experiment_id_; 187 DISALLOW_COPY_AND_ASSIGN(TestFormStructure); 188}; 189 190class TestAutofillManager : public AutofillManager { 191 public: 192 TestAutofillManager(AutofillDriver* driver, 193 AutofillManagerDelegate* manager_delegate, 194 TestPersonalDataManager* personal_manager) 195 : AutofillManager(driver, manager_delegate, personal_manager), 196 autofill_enabled_(true) { 197 set_metric_logger(new testing::NiceMock<MockAutofillMetrics>); 198 } 199 virtual ~TestAutofillManager() {} 200 201 virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; } 202 203 void set_autofill_enabled(bool autofill_enabled) { 204 autofill_enabled_ = autofill_enabled; 205 } 206 207 MockAutofillMetrics* metric_logger() { 208 return static_cast<MockAutofillMetrics*>(const_cast<AutofillMetrics*>( 209 AutofillManager::metric_logger())); 210 } 211 212 void AddSeenForm(const FormData& form, 213 const std::vector<ServerFieldType>& heuristic_types, 214 const std::vector<ServerFieldType>& server_types, 215 const std::string& experiment_id) { 216 FormData empty_form = form; 217 for (size_t i = 0; i < empty_form.fields.size(); ++i) { 218 empty_form.fields[i].value = base::string16(); 219 } 220 221 // |form_structure| will be owned by |form_structures()|. 222 TestFormStructure* form_structure = new TestFormStructure(empty_form); 223 form_structure->SetFieldTypes(heuristic_types, server_types); 224 form_structure->set_server_experiment_id(experiment_id); 225 form_structures()->push_back(form_structure); 226 } 227 228 void FormSubmitted(const FormData& form, const TimeTicks& timestamp) { 229 message_loop_runner_ = new content::MessageLoopRunner(); 230 if (!OnFormSubmitted(form, timestamp)) 231 return; 232 233 // Wait for the asynchronous FormSubmitted() call to complete. 234 message_loop_runner_->Run(); 235 } 236 237 virtual void UploadFormDataAsyncCallback( 238 const FormStructure* submitted_form, 239 const base::TimeTicks& load_time, 240 const base::TimeTicks& interaction_time, 241 const base::TimeTicks& submission_time) OVERRIDE { 242 message_loop_runner_->Quit(); 243 244 AutofillManager::UploadFormDataAsyncCallback(submitted_form, 245 load_time, 246 interaction_time, 247 submission_time); 248 } 249 250 private: 251 bool autofill_enabled_; 252 scoped_refptr<content::MessageLoopRunner> message_loop_runner_; 253 254 DISALLOW_COPY_AND_ASSIGN(TestAutofillManager); 255}; 256 257} // namespace 258 259class AutofillMetricsTest : public ChromeRenderViewHostTestHarness { 260 public: 261 virtual ~AutofillMetricsTest(); 262 263 virtual void SetUp() OVERRIDE; 264 virtual void TearDown() OVERRIDE; 265 266 protected: 267 scoped_ptr<ConfirmInfoBarDelegate> CreateDelegate( 268 MockAutofillMetrics* metric_logger); 269 270 scoped_ptr<TestAutofillDriver> autofill_driver_; 271 scoped_ptr<TestAutofillManager> autofill_manager_; 272 scoped_ptr<TestPersonalDataManager> personal_data_; 273 scoped_ptr<AutofillExternalDelegate> external_delegate_; 274}; 275 276AutofillMetricsTest::~AutofillMetricsTest() { 277 // Order of destruction is important as AutofillManager relies on 278 // PersonalDataManager to be around when it gets destroyed. 279 autofill_manager_.reset(); 280} 281 282void AutofillMetricsTest::SetUp() { 283 ChromeRenderViewHostTestHarness::SetUp(); 284 285 // Ensure Mac OS X does not pop up a modal dialog for the Address Book. 286 autofill::test::DisableSystemServices(profile()); 287 288 PersonalDataManagerFactory::GetInstance()->SetTestingFactory(profile(), NULL); 289 290 TabAutofillManagerDelegate::CreateForWebContents(web_contents()); 291 292 personal_data_.reset(new TestPersonalDataManager()); 293 personal_data_->SetBrowserContext(profile()); 294 personal_data_->SetPrefService(profile()->GetPrefs()); 295 autofill_driver_.reset(new TestAutofillDriver(web_contents())); 296 autofill_manager_.reset(new TestAutofillManager( 297 autofill_driver_.get(), 298 TabAutofillManagerDelegate::FromWebContents(web_contents()), 299 personal_data_.get())); 300 301 external_delegate_.reset(new AutofillExternalDelegate( 302 web_contents(), 303 autofill_manager_.get(), 304 autofill_driver_.get())); 305 autofill_manager_->SetExternalDelegate(external_delegate_.get()); 306} 307 308void AutofillMetricsTest::TearDown() { 309 // Order of destruction is important as AutofillManager relies on 310 // PersonalDataManager to be around when it gets destroyed. Also, a real 311 // AutofillManager is tied to the lifetime of the WebContents, so it must 312 // be destroyed at the destruction of the WebContents. 313 autofill_manager_.reset(); 314 autofill_driver_.reset(); 315 personal_data_.reset(); 316 ChromeRenderViewHostTestHarness::TearDown(); 317} 318 319scoped_ptr<ConfirmInfoBarDelegate> AutofillMetricsTest::CreateDelegate( 320 MockAutofillMetrics* metric_logger) { 321 EXPECT_CALL(*metric_logger, 322 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_SHOWN)); 323 324 CreditCard credit_card; 325 return AutofillCCInfoBarDelegate::Create( 326 metric_logger, 327 base::Bind( 328 base::IgnoreResult(&TestPersonalDataManager::SaveImportedCreditCard), 329 base::Unretained(personal_data_.get()), credit_card)); 330} 331 332// Test that we log quality metrics appropriately. 333TEST_F(AutofillMetricsTest, QualityMetrics) { 334 // Set up our form data. 335 FormData form; 336 form.name = ASCIIToUTF16("TestForm"); 337 form.method = ASCIIToUTF16("POST"); 338 form.origin = GURL("http://example.com/form.html"); 339 form.action = GURL("http://example.com/submit.html"); 340 form.user_submitted = true; 341 342 std::vector<ServerFieldType> heuristic_types, server_types; 343 FormFieldData field; 344 345 test::CreateTestFormField( 346 "Autofilled", "autofilled", "Elvis Aaron Presley", "text", &field); 347 field.is_autofilled = true; 348 form.fields.push_back(field); 349 heuristic_types.push_back(NAME_FULL); 350 server_types.push_back(NAME_FIRST); 351 352 test::CreateTestFormField( 353 "Autofill Failed", "autofillfailed", "buddy@gmail.com", "text", &field); 354 field.is_autofilled = false; 355 form.fields.push_back(field); 356 heuristic_types.push_back(PHONE_HOME_NUMBER); 357 server_types.push_back(EMAIL_ADDRESS); 358 359 test::CreateTestFormField("Empty", "empty", "", "text", &field); 360 field.is_autofilled = false; 361 form.fields.push_back(field); 362 heuristic_types.push_back(NAME_FULL); 363 server_types.push_back(NAME_FIRST); 364 365 test::CreateTestFormField("Unknown", "unknown", "garbage", "text", &field); 366 field.is_autofilled = false; 367 form.fields.push_back(field); 368 heuristic_types.push_back(PHONE_HOME_NUMBER); 369 server_types.push_back(EMAIL_ADDRESS); 370 371 test::CreateTestFormField("Select", "select", "USA", "select-one", &field); 372 field.is_autofilled = false; 373 form.fields.push_back(field); 374 heuristic_types.push_back(UNKNOWN_TYPE); 375 server_types.push_back(NO_SERVER_DATA); 376 377 test::CreateTestFormField("Phone", "phone", "2345678901", "tel", &field); 378 field.is_autofilled = true; 379 form.fields.push_back(field); 380 heuristic_types.push_back(PHONE_HOME_CITY_AND_NUMBER); 381 server_types.push_back(PHONE_HOME_WHOLE_NUMBER); 382 383 // Simulate having seen this form on page load. 384 autofill_manager_->AddSeenForm(form, heuristic_types, server_types, 385 std::string()); 386 387 // Establish our expectations. 388 ::testing::InSequence dummy; 389 EXPECT_CALL(*autofill_manager_->metric_logger(), 390 LogServerExperimentIdForUpload(std::string())); 391 // Autofilled field 392 EXPECT_CALL(*autofill_manager_->metric_logger(), 393 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 394 std::string())); 395 EXPECT_CALL(*autofill_manager_->metric_logger(), 396 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH, 397 NAME_FULL, std::string())); 398 EXPECT_CALL(*autofill_manager_->metric_logger(), 399 LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH, 400 NAME_FULL, std::string())); 401 EXPECT_CALL(*autofill_manager_->metric_logger(), 402 LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH, 403 NAME_FULL, std::string())); 404 EXPECT_CALL(*autofill_manager_->metric_logger(), 405 LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED, 406 std::string())); 407 // Non-autofilled field for which we had data 408 EXPECT_CALL(*autofill_manager_->metric_logger(), 409 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 410 std::string())); 411 EXPECT_CALL(*autofill_manager_->metric_logger(), 412 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MISMATCH, 413 EMAIL_ADDRESS, std::string())); 414 EXPECT_CALL(*autofill_manager_->metric_logger(), 415 LogServerTypePrediction(AutofillMetrics::TYPE_MATCH, 416 EMAIL_ADDRESS, std::string())); 417 EXPECT_CALL(*autofill_manager_->metric_logger(), 418 LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH, 419 EMAIL_ADDRESS, std::string())); 420 EXPECT_CALL(*autofill_manager_->metric_logger(), 421 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 422 std::string())); 423 EXPECT_CALL(*autofill_manager_->metric_logger(), 424 LogQualityMetric( 425 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 426 std::string())); 427 EXPECT_CALL(*autofill_manager_->metric_logger(), 428 LogQualityMetric( 429 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH, 430 std::string())); 431 // Empty field 432 EXPECT_CALL(*autofill_manager_->metric_logger(), 433 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 434 std::string())); 435 // Unknown field 436 EXPECT_CALL(*autofill_manager_->metric_logger(), 437 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 438 std::string())); 439 // <select> field 440 EXPECT_CALL(*autofill_manager_->metric_logger(), 441 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 442 std::string())); 443 EXPECT_CALL(*autofill_manager_->metric_logger(), 444 LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 445 ADDRESS_HOME_COUNTRY, std::string())); 446 EXPECT_CALL(*autofill_manager_->metric_logger(), 447 LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 448 ADDRESS_HOME_COUNTRY, std::string())); 449 EXPECT_CALL(*autofill_manager_->metric_logger(), 450 LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 451 ADDRESS_HOME_COUNTRY, std::string())); 452 // Phone field 453 EXPECT_CALL(*autofill_manager_->metric_logger(), 454 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 455 std::string())); 456 EXPECT_CALL(*autofill_manager_->metric_logger(), 457 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH, 458 PHONE_HOME_WHOLE_NUMBER, std::string())); 459 EXPECT_CALL(*autofill_manager_->metric_logger(), 460 LogServerTypePrediction(AutofillMetrics::TYPE_MATCH, 461 PHONE_HOME_WHOLE_NUMBER, std::string())); 462 EXPECT_CALL(*autofill_manager_->metric_logger(), 463 LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH, 464 PHONE_HOME_WHOLE_NUMBER, std::string())); 465 EXPECT_CALL(*autofill_manager_->metric_logger(), 466 LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED, 467 std::string())); 468 EXPECT_CALL(*autofill_manager_->metric_logger(), 469 LogUserHappinessMetric( 470 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME)); 471 472 // Simulate form submission. 473 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 474 TimeTicks::Now())); 475} 476 477// Test that we log the appropriate additional metrics when Autofill failed. 478TEST_F(AutofillMetricsTest, QualityMetricsForFailure) { 479 // Set up our form data. 480 FormData form; 481 form.name = ASCIIToUTF16("TestForm"); 482 form.method = ASCIIToUTF16("POST"); 483 form.origin = GURL("http://example.com/form.html"); 484 form.action = GURL("http://example.com/submit.html"); 485 form.user_submitted = true; 486 487 struct { 488 const char* label; 489 const char* name; 490 const char* value; 491 ServerFieldType heuristic_type; 492 ServerFieldType server_type; 493 AutofillMetrics::QualityMetric heuristic_metric; 494 AutofillMetrics::QualityMetric server_metric; 495 } failure_cases[] = { 496 { 497 "Heuristics unknown, server unknown", "0,0", "Elvis", 498 UNKNOWN_TYPE, NO_SERVER_DATA, 499 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_UNKNOWN, 500 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_UNKNOWN 501 }, 502 { 503 "Heuristics match, server unknown", "1,0", "Aaron", 504 NAME_MIDDLE, NO_SERVER_DATA, 505 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MATCH, 506 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_UNKNOWN 507 }, 508 { 509 "Heuristics mismatch, server unknown", "2,0", "Presley", 510 PHONE_HOME_NUMBER, NO_SERVER_DATA, 511 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 512 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_UNKNOWN 513 }, 514 { 515 "Heuristics unknown, server match", "0,1", "theking@gmail.com", 516 UNKNOWN_TYPE, EMAIL_ADDRESS, 517 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_UNKNOWN, 518 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH 519 }, 520 { 521 "Heuristics match, server match", "1,1", "3734 Elvis Presley Blvd.", 522 ADDRESS_HOME_LINE1, ADDRESS_HOME_LINE1, 523 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MATCH, 524 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH 525 }, 526 { 527 "Heuristics mismatch, server match", "2,1", "Apt. 10", 528 PHONE_HOME_NUMBER, ADDRESS_HOME_LINE2, 529 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 530 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH 531 }, 532 { 533 "Heuristics unknown, server mismatch", "0,2", "Memphis", 534 UNKNOWN_TYPE, PHONE_HOME_NUMBER, 535 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_UNKNOWN, 536 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH 537 }, 538 { 539 "Heuristics match, server mismatch", "1,2", "Tennessee", 540 ADDRESS_HOME_STATE, PHONE_HOME_NUMBER, 541 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MATCH, 542 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH 543 }, 544 { 545 "Heuristics mismatch, server mismatch", "2,2", "38116", 546 PHONE_HOME_NUMBER, PHONE_HOME_NUMBER, 547 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 548 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH 549 } 550 }; 551 552 std::vector<ServerFieldType> heuristic_types, server_types; 553 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(failure_cases); ++i) { 554 FormFieldData field; 555 test::CreateTestFormField(failure_cases[i].label, 556 failure_cases[i].name, 557 failure_cases[i].value, "text", &field); 558 form.fields.push_back(field); 559 heuristic_types.push_back(failure_cases[i].heuristic_type); 560 server_types.push_back(failure_cases[i].server_type); 561 562 } 563 564 // Simulate having seen this form with the desired heuristic and server types. 565 // |form_structure| will be owned by |autofill_manager_|. 566 autofill_manager_->AddSeenForm(form, heuristic_types, server_types, 567 std::string()); 568 569 570 // Establish our expectations. 571 ::testing::InSequence dummy; 572 EXPECT_CALL(*autofill_manager_->metric_logger(), 573 LogServerExperimentIdForUpload(std::string())); 574 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(failure_cases); ++i) { 575 EXPECT_CALL(*autofill_manager_->metric_logger(), 576 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 577 std::string())); 578 EXPECT_CALL(*autofill_manager_->metric_logger(), 579 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 580 std::string())); 581 EXPECT_CALL(*autofill_manager_->metric_logger(), 582 LogQualityMetric(failure_cases[i].heuristic_metric, 583 std::string())); 584 EXPECT_CALL(*autofill_manager_->metric_logger(), 585 LogQualityMetric(failure_cases[i].server_metric, 586 std::string())); 587 } 588 589 // Simulate form submission. 590 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 591 TimeTicks::Now())); 592} 593 594// Test that we behave sanely when the cached form differs from the submitted 595// one. 596TEST_F(AutofillMetricsTest, SaneMetricsWithCacheMismatch) { 597 // Set up our form data. 598 FormData form; 599 form.name = ASCIIToUTF16("TestForm"); 600 form.method = ASCIIToUTF16("POST"); 601 form.origin = GURL("http://example.com/form.html"); 602 form.action = GURL("http://example.com/submit.html"); 603 form.user_submitted = true; 604 605 std::vector<ServerFieldType> heuristic_types, server_types; 606 607 FormFieldData field; 608 test::CreateTestFormField( 609 "Both match", "match", "Elvis Aaron Presley", "text", &field); 610 field.is_autofilled = true; 611 form.fields.push_back(field); 612 heuristic_types.push_back(NAME_FULL); 613 server_types.push_back(NAME_FULL); 614 test::CreateTestFormField( 615 "Both mismatch", "mismatch", "buddy@gmail.com", "text", &field); 616 field.is_autofilled = false; 617 form.fields.push_back(field); 618 heuristic_types.push_back(PHONE_HOME_NUMBER); 619 server_types.push_back(PHONE_HOME_NUMBER); 620 test::CreateTestFormField( 621 "Only heuristics match", "mixed", "Memphis", "text", &field); 622 field.is_autofilled = false; 623 form.fields.push_back(field); 624 heuristic_types.push_back(ADDRESS_HOME_CITY); 625 server_types.push_back(PHONE_HOME_NUMBER); 626 test::CreateTestFormField("Unknown", "unknown", "garbage", "text", &field); 627 field.is_autofilled = false; 628 form.fields.push_back(field); 629 heuristic_types.push_back(UNKNOWN_TYPE); 630 server_types.push_back(UNKNOWN_TYPE); 631 632 // Simulate having seen this form with the desired heuristic and server types. 633 // |form_structure| will be owned by |autofill_manager_|. 634 autofill_manager_->AddSeenForm(form, heuristic_types, server_types, 635 std::string()); 636 637 638 // Add a field and re-arrange the remaining form fields before submitting. 639 std::vector<FormFieldData> cached_fields = form.fields; 640 form.fields.clear(); 641 test::CreateTestFormField( 642 "New field", "new field", "Tennessee", "text", &field); 643 form.fields.push_back(field); 644 form.fields.push_back(cached_fields[2]); 645 form.fields.push_back(cached_fields[1]); 646 form.fields.push_back(cached_fields[3]); 647 form.fields.push_back(cached_fields[0]); 648 649 // Establish our expectations. 650 ::testing::InSequence dummy; 651 // New field 652 EXPECT_CALL(*autofill_manager_->metric_logger(), 653 LogServerExperimentIdForUpload(std::string())); 654 EXPECT_CALL(*autofill_manager_->metric_logger(), 655 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 656 std::string())); 657 EXPECT_CALL(*autofill_manager_->metric_logger(), 658 LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 659 ADDRESS_HOME_STATE, std::string())); 660 EXPECT_CALL(*autofill_manager_->metric_logger(), 661 LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 662 ADDRESS_HOME_STATE, std::string())); 663 EXPECT_CALL(*autofill_manager_->metric_logger(), 664 LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 665 ADDRESS_HOME_STATE, std::string())); 666 EXPECT_CALL(*autofill_manager_->metric_logger(), 667 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 668 std::string())); 669 EXPECT_CALL(*autofill_manager_->metric_logger(), 670 LogQualityMetric( 671 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_UNKNOWN, 672 std::string())); 673 EXPECT_CALL(*autofill_manager_->metric_logger(), 674 LogQualityMetric( 675 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_UNKNOWN, 676 std::string())); 677 // Only heuristics match 678 EXPECT_CALL(*autofill_manager_->metric_logger(), 679 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 680 std::string())); 681 EXPECT_CALL(*autofill_manager_->metric_logger(), 682 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH, 683 ADDRESS_HOME_CITY, std::string())); 684 EXPECT_CALL(*autofill_manager_->metric_logger(), 685 LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH, 686 ADDRESS_HOME_CITY, std::string())); 687 EXPECT_CALL(*autofill_manager_->metric_logger(), 688 LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH, 689 ADDRESS_HOME_CITY, std::string())); 690 EXPECT_CALL(*autofill_manager_->metric_logger(), 691 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 692 std::string())); 693 EXPECT_CALL(*autofill_manager_->metric_logger(), 694 LogQualityMetric( 695 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MATCH, 696 std::string())); 697 EXPECT_CALL(*autofill_manager_->metric_logger(), 698 LogQualityMetric( 699 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH, 700 std::string())); 701 // Both mismatch 702 EXPECT_CALL(*autofill_manager_->metric_logger(), 703 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 704 std::string())); 705 EXPECT_CALL(*autofill_manager_->metric_logger(), 706 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MISMATCH, 707 EMAIL_ADDRESS, std::string())); 708 EXPECT_CALL(*autofill_manager_->metric_logger(), 709 LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH, 710 EMAIL_ADDRESS, std::string())); 711 EXPECT_CALL(*autofill_manager_->metric_logger(), 712 LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH, 713 EMAIL_ADDRESS, std::string())); 714 EXPECT_CALL(*autofill_manager_->metric_logger(), 715 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 716 std::string())); 717 EXPECT_CALL(*autofill_manager_->metric_logger(), 718 LogQualityMetric( 719 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 720 std::string())); 721 EXPECT_CALL(*autofill_manager_->metric_logger(), 722 LogQualityMetric( 723 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH, 724 std::string())); 725 // Unknown 726 EXPECT_CALL(*autofill_manager_->metric_logger(), 727 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 728 std::string())); 729 // Both match 730 EXPECT_CALL(*autofill_manager_->metric_logger(), 731 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 732 std::string())); 733 EXPECT_CALL(*autofill_manager_->metric_logger(), 734 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH, 735 NAME_FULL, std::string())); 736 EXPECT_CALL(*autofill_manager_->metric_logger(), 737 LogServerTypePrediction(AutofillMetrics::TYPE_MATCH, 738 NAME_FULL, std::string())); 739 EXPECT_CALL(*autofill_manager_->metric_logger(), 740 LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH, 741 NAME_FULL, std::string())); 742 EXPECT_CALL(*autofill_manager_->metric_logger(), 743 LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED, 744 std::string())); 745 746 // Simulate form submission. 747 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 748 TimeTicks::Now())); 749} 750 751// Verify that we correctly log metrics regarding developer engagement. 752TEST_F(AutofillMetricsTest, DeveloperEngagement) { 753 // Start with a non-fillable form. 754 FormData form; 755 form.name = ASCIIToUTF16("TestForm"); 756 form.method = ASCIIToUTF16("POST"); 757 form.origin = GURL("http://example.com/form.html"); 758 form.action = GURL("http://example.com/submit.html"); 759 760 FormFieldData field; 761 test::CreateTestFormField("Name", "name", "", "text", &field); 762 form.fields.push_back(field); 763 test::CreateTestFormField("Email", "email", "", "text", &field); 764 form.fields.push_back(field); 765 766 std::vector<FormData> forms(1, form); 767 768 // Ensure no metrics are logged when loading a non-fillable form. 769 { 770 EXPECT_CALL(*autofill_manager_->metric_logger(), 771 LogDeveloperEngagementMetric(_)).Times(0); 772 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 773 autofill::NO_SPECIAL_FORMS_SEEN); 774 autofill_manager_->Reset(); 775 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 776 } 777 778 // Add another field to the form, so that it becomes fillable. 779 test::CreateTestFormField("Phone", "phone", "", "text", &field); 780 forms.back().fields.push_back(field); 781 782 // Expect only the "form parsed" metric to be logged; no metrics about 783 // author-specified field type hints. 784 { 785 EXPECT_CALL( 786 *autofill_manager_->metric_logger(), 787 LogDeveloperEngagementMetric( 788 AutofillMetrics::FILLABLE_FORM_PARSED)).Times(1); 789 EXPECT_CALL( 790 *autofill_manager_->metric_logger(), 791 LogDeveloperEngagementMetric( 792 AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS)).Times(0); 793 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 794 autofill::NO_SPECIAL_FORMS_SEEN); 795 autofill_manager_->Reset(); 796 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 797 } 798 799 // Add some fields with an author-specified field type to the form. 800 // We need to add at least three fields, because a form must have at least 801 // three fillable fields to be considered to be autofillable; and if at least 802 // one field specifies an explicit type hint, we don't apply any of our usual 803 // local heuristics to detect field types in the rest of the form. 804 test::CreateTestFormField("", "", "", "text", &field); 805 field.autocomplete_attribute = "given-name"; 806 forms.back().fields.push_back(field); 807 test::CreateTestFormField("", "", "", "text", &field); 808 field.autocomplete_attribute = "email"; 809 forms.back().fields.push_back(field); 810 test::CreateTestFormField("", "", "", "text", &field); 811 field.autocomplete_attribute = "address-line1"; 812 forms.back().fields.push_back(field); 813 814 // Expect both the "form parsed" metric and the author-specified field type 815 // hints metric to be logged. 816 { 817 EXPECT_CALL( 818 *autofill_manager_->metric_logger(), 819 LogDeveloperEngagementMetric( 820 AutofillMetrics::FILLABLE_FORM_PARSED)).Times(1); 821 EXPECT_CALL( 822 *autofill_manager_->metric_logger(), 823 LogDeveloperEngagementMetric( 824 AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS)).Times(1); 825 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 826 autofill::NO_SPECIAL_FORMS_SEEN); 827 autofill_manager_->Reset(); 828 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 829 } 830} 831 832// Test that we don't log quality metrics for non-autofillable forms. 833TEST_F(AutofillMetricsTest, NoQualityMetricsForNonAutofillableForms) { 834 // Forms must include at least three fields to be auto-fillable. 835 FormData form; 836 form.name = ASCIIToUTF16("TestForm"); 837 form.method = ASCIIToUTF16("POST"); 838 form.origin = GURL("http://example.com/form.html"); 839 form.action = GURL("http://example.com/submit.html"); 840 form.user_submitted = true; 841 842 FormFieldData field; 843 test::CreateTestFormField( 844 "Autofilled", "autofilled", "Elvis Presley", "text", &field); 845 field.is_autofilled = true; 846 form.fields.push_back(field); 847 test::CreateTestFormField( 848 "Autofill Failed", "autofillfailed", "buddy@gmail.com", "text", &field); 849 form.fields.push_back(field); 850 851 // Simulate form submission. 852 EXPECT_CALL(*autofill_manager_->metric_logger(), 853 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 854 std::string())).Times(0); 855 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 856 TimeTicks::Now())); 857 858 // Search forms are not auto-fillable. 859 form.action = GURL("http://example.com/search?q=Elvis%20Presley"); 860 test::CreateTestFormField("Empty", "empty", "", "text", &field); 861 form.fields.push_back(field); 862 863 // Simulate form submission. 864 EXPECT_CALL(*autofill_manager_->metric_logger(), 865 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 866 std::string())).Times(0); 867 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 868 TimeTicks::Now())); 869} 870 871// Test that we recored the experiment id appropriately. 872TEST_F(AutofillMetricsTest, QualityMetricsWithExperimentId) { 873 // Set up our form data. 874 FormData form; 875 form.name = ASCIIToUTF16("TestForm"); 876 form.method = ASCIIToUTF16("POST"); 877 form.origin = GURL("http://example.com/form.html"); 878 form.action = GURL("http://example.com/submit.html"); 879 form.user_submitted = true; 880 881 std::vector<ServerFieldType> heuristic_types, server_types; 882 FormFieldData field; 883 884 test::CreateTestFormField( 885 "Autofilled", "autofilled", "Elvis Aaron Presley", "text", &field); 886 field.is_autofilled = true; 887 form.fields.push_back(field); 888 heuristic_types.push_back(NAME_FULL); 889 server_types.push_back(NAME_FIRST); 890 891 test::CreateTestFormField( 892 "Autofill Failed", "autofillfailed", "buddy@gmail.com", "text", &field); 893 field.is_autofilled = false; 894 form.fields.push_back(field); 895 heuristic_types.push_back(PHONE_HOME_NUMBER); 896 server_types.push_back(EMAIL_ADDRESS); 897 898 test::CreateTestFormField("Empty", "empty", "", "text", &field); 899 field.is_autofilled = false; 900 form.fields.push_back(field); 901 heuristic_types.push_back(NAME_FULL); 902 server_types.push_back(NAME_FIRST); 903 904 test::CreateTestFormField("Unknown", "unknown", "garbage", "text", &field); 905 field.is_autofilled = false; 906 form.fields.push_back(field); 907 heuristic_types.push_back(PHONE_HOME_NUMBER); 908 server_types.push_back(EMAIL_ADDRESS); 909 910 test::CreateTestFormField("Select", "select", "USA", "select-one", &field); 911 field.is_autofilled = false; 912 form.fields.push_back(field); 913 heuristic_types.push_back(UNKNOWN_TYPE); 914 server_types.push_back(NO_SERVER_DATA); 915 916 const std::string experiment_id = "ThatOughtaDoIt"; 917 918 // Simulate having seen this form on page load. 919 // |form_structure| will be owned by |autofill_manager_|. 920 autofill_manager_->AddSeenForm(form, heuristic_types, server_types, 921 experiment_id); 922 923 // Establish our expectations. 924 ::testing::InSequence dummy; 925 EXPECT_CALL(*autofill_manager_->metric_logger(), 926 LogServerExperimentIdForUpload(experiment_id)); 927 // Autofilled field 928 EXPECT_CALL(*autofill_manager_->metric_logger(), 929 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 930 experiment_id)); 931 EXPECT_CALL(*autofill_manager_->metric_logger(), 932 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH, 933 NAME_FULL, experiment_id)); 934 EXPECT_CALL(*autofill_manager_->metric_logger(), 935 LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH, 936 NAME_FULL, experiment_id)); 937 EXPECT_CALL(*autofill_manager_->metric_logger(), 938 LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH, 939 NAME_FULL, experiment_id)); 940 EXPECT_CALL(*autofill_manager_->metric_logger(), 941 LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED, 942 experiment_id)); 943 // Non-autofilled field for which we had data 944 EXPECT_CALL(*autofill_manager_->metric_logger(), 945 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 946 experiment_id)); 947 EXPECT_CALL(*autofill_manager_->metric_logger(), 948 LogHeuristicTypePrediction(AutofillMetrics::TYPE_MISMATCH, 949 EMAIL_ADDRESS, experiment_id)); 950 EXPECT_CALL(*autofill_manager_->metric_logger(), 951 LogServerTypePrediction(AutofillMetrics::TYPE_MATCH, 952 EMAIL_ADDRESS, experiment_id)); 953 EXPECT_CALL(*autofill_manager_->metric_logger(), 954 LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH, 955 EMAIL_ADDRESS, experiment_id)); 956 EXPECT_CALL(*autofill_manager_->metric_logger(), 957 LogQualityMetric(AutofillMetrics::FIELD_NOT_AUTOFILLED, 958 experiment_id)); 959 EXPECT_CALL(*autofill_manager_->metric_logger(), 960 LogQualityMetric( 961 AutofillMetrics::NOT_AUTOFILLED_HEURISTIC_TYPE_MISMATCH, 962 experiment_id)); 963 EXPECT_CALL(*autofill_manager_->metric_logger(), 964 LogQualityMetric( 965 AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH, 966 experiment_id)); 967 // Empty field 968 EXPECT_CALL(*autofill_manager_->metric_logger(), 969 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 970 experiment_id)); 971 // Unknown field 972 EXPECT_CALL(*autofill_manager_->metric_logger(), 973 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 974 experiment_id)); 975 // <select> field 976 EXPECT_CALL(*autofill_manager_->metric_logger(), 977 LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED, 978 experiment_id)); 979 EXPECT_CALL(*autofill_manager_->metric_logger(), 980 LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 981 ADDRESS_HOME_COUNTRY, experiment_id)); 982 EXPECT_CALL(*autofill_manager_->metric_logger(), 983 LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 984 ADDRESS_HOME_COUNTRY, experiment_id)); 985 EXPECT_CALL(*autofill_manager_->metric_logger(), 986 LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN, 987 ADDRESS_HOME_COUNTRY, experiment_id)); 988 989 // Simulate form submission. 990 EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form, 991 TimeTicks::Now())); 992} 993 994// Test that the profile count is logged correctly. 995TEST_F(AutofillMetricsTest, StoredProfileCount) { 996 // The metric should be logged when the profiles are first loaded. 997 EXPECT_CALL(*personal_data_->metric_logger(), 998 LogStoredProfileCount(2)).Times(1); 999 personal_data_->LoadProfiles(); 1000 1001 // The metric should only be logged once. 1002 EXPECT_CALL(*personal_data_->metric_logger(), 1003 LogStoredProfileCount(::testing::_)).Times(0); 1004 personal_data_->LoadProfiles(); 1005} 1006 1007// Test that we correctly log when Autofill is enabled. 1008TEST_F(AutofillMetricsTest, AutofillIsEnabledAtStartup) { 1009 personal_data_->set_autofill_enabled(true); 1010 EXPECT_CALL(*personal_data_->metric_logger(), 1011 LogIsAutofillEnabledAtStartup(true)).Times(1); 1012 personal_data_->Init(profile(), profile()->GetPrefs()); 1013} 1014 1015// Test that we correctly log when Autofill is disabled. 1016TEST_F(AutofillMetricsTest, AutofillIsDisabledAtStartup) { 1017 personal_data_->set_autofill_enabled(false); 1018 EXPECT_CALL(*personal_data_->metric_logger(), 1019 LogIsAutofillEnabledAtStartup(false)).Times(1); 1020 personal_data_->Init(profile(), profile()->GetPrefs()); 1021} 1022 1023// Test that we log the number of Autofill suggestions when filling a form. 1024TEST_F(AutofillMetricsTest, AddressSuggestionsCount) { 1025 // Set up our form data. 1026 FormData form; 1027 form.name = ASCIIToUTF16("TestForm"); 1028 form.method = ASCIIToUTF16("POST"); 1029 form.origin = GURL("http://example.com/form.html"); 1030 form.action = GURL("http://example.com/submit.html"); 1031 form.user_submitted = true; 1032 1033 FormFieldData field; 1034 std::vector<ServerFieldType> field_types; 1035 test::CreateTestFormField("Name", "name", "", "text", &field); 1036 form.fields.push_back(field); 1037 field_types.push_back(NAME_FULL); 1038 test::CreateTestFormField("Email", "email", "", "email", &field); 1039 form.fields.push_back(field); 1040 field_types.push_back(EMAIL_ADDRESS); 1041 test::CreateTestFormField("Phone", "phone", "", "tel", &field); 1042 form.fields.push_back(field); 1043 field_types.push_back(PHONE_HOME_NUMBER); 1044 1045 // Simulate having seen this form on page load. 1046 // |form_structure| will be owned by |autofill_manager_|. 1047 autofill_manager_->AddSeenForm(form, field_types, field_types, 1048 std::string()); 1049 1050 // Establish our expectations. 1051 ::testing::InSequence dummy; 1052 EXPECT_CALL(*autofill_manager_->metric_logger(), 1053 LogAddressSuggestionsCount(2)).Times(1); 1054 1055 // Simulate activating the autofill popup for the phone field. 1056 autofill_manager_->OnQueryFormFieldAutofill( 1057 0, form, field, gfx::Rect(), false); 1058 1059 // Simulate activating the autofill popup for the email field after typing. 1060 // No new metric should be logged, since we're still on the same page. 1061 test::CreateTestFormField("Email", "email", "b", "email", &field); 1062 autofill_manager_->OnQueryFormFieldAutofill( 1063 0, form, field, gfx::Rect(), false); 1064 1065 // Reset the autofill manager state. 1066 autofill_manager_->Reset(); 1067 autofill_manager_->AddSeenForm(form, field_types, field_types, 1068 std::string()); 1069 1070 // Establish our expectations. 1071 EXPECT_CALL(*autofill_manager_->metric_logger(), 1072 LogAddressSuggestionsCount(1)).Times(1); 1073 1074 // Simulate activating the autofill popup for the email field after typing. 1075 autofill_manager_->OnQueryFormFieldAutofill( 1076 0, form, field, gfx::Rect(), false); 1077 1078 // Reset the autofill manager state again. 1079 autofill_manager_->Reset(); 1080 autofill_manager_->AddSeenForm(form, field_types, field_types, 1081 std::string()); 1082 1083 // Establish our expectations. 1084 EXPECT_CALL(*autofill_manager_->metric_logger(), 1085 LogAddressSuggestionsCount(::testing::_)).Times(0); 1086 1087 // Simulate activating the autofill popup for the email field after typing. 1088 form.fields[0].is_autofilled = true; 1089 autofill_manager_->OnQueryFormFieldAutofill( 1090 0, form, field, gfx::Rect(), false); 1091} 1092 1093// Test that we log whether Autofill is enabled when filling a form. 1094TEST_F(AutofillMetricsTest, AutofillIsEnabledAtPageLoad) { 1095 // Establish our expectations. 1096 ::testing::InSequence dummy; 1097 EXPECT_CALL(*autofill_manager_->metric_logger(), 1098 LogIsAutofillEnabledAtPageLoad(true)).Times(1); 1099 1100 autofill_manager_->set_autofill_enabled(true); 1101 autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks(), 1102 autofill::NO_SPECIAL_FORMS_SEEN); 1103 1104 // Reset the autofill manager state. 1105 autofill_manager_->Reset(); 1106 1107 // Establish our expectations. 1108 EXPECT_CALL(*autofill_manager_->metric_logger(), 1109 LogIsAutofillEnabledAtPageLoad(false)).Times(1); 1110 1111 autofill_manager_->set_autofill_enabled(false); 1112 autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks(), 1113 autofill::NO_SPECIAL_FORMS_SEEN); 1114} 1115 1116// Test that credit card infobar metrics are logged correctly. 1117TEST_F(AutofillMetricsTest, CreditCardInfoBar) { 1118 testing::NiceMock<MockAutofillMetrics> metric_logger; 1119 ::testing::InSequence dummy; 1120 1121 // Accept the infobar. 1122 { 1123 scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger)); 1124 ASSERT_TRUE(infobar); 1125 EXPECT_CALL(*personal_data_, SaveImportedCreditCard(_)); 1126 EXPECT_CALL(metric_logger, 1127 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_ACCEPTED)).Times(1); 1128 EXPECT_CALL(metric_logger, 1129 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_IGNORED)).Times(0); 1130 EXPECT_TRUE(infobar->Accept()); 1131 } 1132 1133 // Cancel the infobar. 1134 { 1135 scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger)); 1136 ASSERT_TRUE(infobar); 1137 EXPECT_CALL(metric_logger, 1138 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_DENIED)).Times(1); 1139 EXPECT_CALL(metric_logger, 1140 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_IGNORED)).Times(0); 1141 EXPECT_TRUE(infobar->Cancel()); 1142 } 1143 1144 // Dismiss the infobar. 1145 { 1146 scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger)); 1147 ASSERT_TRUE(infobar); 1148 EXPECT_CALL(metric_logger, 1149 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_DENIED)).Times(1); 1150 EXPECT_CALL(metric_logger, 1151 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_IGNORED)).Times(0); 1152 infobar->InfoBarDismissed(); 1153 } 1154 1155 // Ignore the infobar. 1156 { 1157 scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger)); 1158 ASSERT_TRUE(infobar); 1159 EXPECT_CALL(metric_logger, 1160 LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_IGNORED)).Times(1); 1161 } 1162} 1163 1164// Test that server query response experiment id metrics are logged correctly. 1165TEST_F(AutofillMetricsTest, ServerQueryExperimentIdForQuery) { 1166 testing::NiceMock<MockAutofillMetrics> metric_logger; 1167 ::testing::InSequence dummy; 1168 1169 // No experiment specified. 1170 EXPECT_CALL(metric_logger, 1171 LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_RECEIVED)); 1172 EXPECT_CALL(metric_logger, 1173 LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_PARSED)); 1174 EXPECT_CALL(metric_logger, 1175 LogServerExperimentIdForQuery(std::string())); 1176 EXPECT_CALL(metric_logger, 1177 LogServerQueryMetric( 1178 AutofillMetrics::QUERY_RESPONSE_MATCHED_LOCAL_HEURISTICS)); 1179 FormStructure::ParseQueryResponse( 1180 "<autofillqueryresponse></autofillqueryresponse>", 1181 std::vector<FormStructure*>(), 1182 metric_logger); 1183 1184 // Experiment "ar1" specified. 1185 EXPECT_CALL(metric_logger, 1186 LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_RECEIVED)); 1187 EXPECT_CALL(metric_logger, 1188 LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_PARSED)); 1189 EXPECT_CALL(metric_logger, 1190 LogServerExperimentIdForQuery("ar1")); 1191 EXPECT_CALL(metric_logger, 1192 LogServerQueryMetric( 1193 AutofillMetrics::QUERY_RESPONSE_MATCHED_LOCAL_HEURISTICS)); 1194 FormStructure::ParseQueryResponse( 1195 "<autofillqueryresponse experimentid=\"ar1\"></autofillqueryresponse>", 1196 std::vector<FormStructure*>(), 1197 metric_logger); 1198} 1199 1200// Verify that we correctly log user happiness metrics dealing with form loading 1201// and form submission. 1202TEST_F(AutofillMetricsTest, UserHappinessFormLoadAndSubmission) { 1203 // Start with a form with insufficiently many fields. 1204 FormData form; 1205 form.name = ASCIIToUTF16("TestForm"); 1206 form.method = ASCIIToUTF16("POST"); 1207 form.origin = GURL("http://example.com/form.html"); 1208 form.action = GURL("http://example.com/submit.html"); 1209 form.user_submitted = true; 1210 1211 FormFieldData field; 1212 test::CreateTestFormField("Name", "name", "", "text", &field); 1213 form.fields.push_back(field); 1214 test::CreateTestFormField("Email", "email", "", "text", &field); 1215 form.fields.push_back(field); 1216 1217 std::vector<FormData> forms(1, form); 1218 1219 // Expect no notifications when the form is first seen. 1220 { 1221 EXPECT_CALL(*autofill_manager_->metric_logger(), 1222 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED)).Times(0); 1223 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 1224 autofill::NO_SPECIAL_FORMS_SEEN); 1225 } 1226 1227 1228 // Expect no notifications when the form is submitted. 1229 { 1230 EXPECT_CALL( 1231 *autofill_manager_->metric_logger(), 1232 LogUserHappinessMetric( 1233 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL)).Times(0); 1234 EXPECT_CALL( 1235 *autofill_manager_->metric_logger(), 1236 LogUserHappinessMetric( 1237 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME)).Times(0); 1238 EXPECT_CALL( 1239 *autofill_manager_->metric_logger(), 1240 LogUserHappinessMetric( 1241 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE)).Times(0); 1242 EXPECT_CALL( 1243 *autofill_manager_->metric_logger(), 1244 LogUserHappinessMetric( 1245 AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)).Times(0); 1246 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1247 } 1248 1249 // Add more fields to the form. 1250 test::CreateTestFormField("Phone", "phone", "", "text", &field); 1251 form.fields.push_back(field); 1252 test::CreateTestFormField("Unknown", "unknown", "", "text", &field); 1253 form.fields.push_back(field); 1254 forms.front() = form; 1255 1256 // Expect a notification when the form is first seen. 1257 { 1258 EXPECT_CALL(*autofill_manager_->metric_logger(), 1259 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED)); 1260 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 1261 autofill::NO_SPECIAL_FORMS_SEEN); 1262 } 1263 1264 // Expect a notification when the form is submitted. 1265 { 1266 EXPECT_CALL(*autofill_manager_->metric_logger(), 1267 LogUserHappinessMetric( 1268 AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)); 1269 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1270 } 1271 1272 // Fill in two of the fields. 1273 form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley"); 1274 form.fields[1].value = ASCIIToUTF16("theking@gmail.com"); 1275 forms.front() = form; 1276 1277 // Expect a notification when the form is submitted. 1278 { 1279 EXPECT_CALL(*autofill_manager_->metric_logger(), 1280 LogUserHappinessMetric( 1281 AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)); 1282 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1283 } 1284 1285 // Fill in the third field. 1286 form.fields[2].value = ASCIIToUTF16("12345678901"); 1287 forms.front() = form; 1288 1289 // Expect notifications when the form is submitted. 1290 { 1291 EXPECT_CALL(*autofill_manager_->metric_logger(), 1292 LogUserHappinessMetric( 1293 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE)); 1294 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1295 } 1296 1297 1298 // Mark one of the fields as autofilled. 1299 form.fields[1].is_autofilled = true; 1300 forms.front() = form; 1301 1302 // Expect notifications when the form is submitted. 1303 { 1304 EXPECT_CALL(*autofill_manager_->metric_logger(), 1305 LogUserHappinessMetric( 1306 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME)); 1307 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1308 } 1309 1310 // Mark all of the fillable fields as autofilled. 1311 form.fields[0].is_autofilled = true; 1312 form.fields[2].is_autofilled = true; 1313 forms.front() = form; 1314 1315 // Expect notifications when the form is submitted. 1316 { 1317 EXPECT_CALL(*autofill_manager_->metric_logger(), 1318 LogUserHappinessMetric( 1319 AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL)); 1320 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1321 } 1322 1323 // Clear out the third field's value. 1324 form.fields[2].value = base::string16(); 1325 forms.front() = form; 1326 1327 // Expect notifications when the form is submitted. 1328 { 1329 EXPECT_CALL(*autofill_manager_->metric_logger(), 1330 LogUserHappinessMetric( 1331 AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)); 1332 autofill_manager_->FormSubmitted(form, TimeTicks::Now()); 1333 } 1334} 1335 1336// Verify that we correctly log user happiness metrics dealing with form 1337// interaction. 1338TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) { 1339 // Load a fillable form. 1340 FormData form; 1341 form.name = ASCIIToUTF16("TestForm"); 1342 form.method = ASCIIToUTF16("POST"); 1343 form.origin = GURL("http://example.com/form.html"); 1344 form.action = GURL("http://example.com/submit.html"); 1345 form.user_submitted = true; 1346 1347 FormFieldData field; 1348 test::CreateTestFormField("Name", "name", "", "text", &field); 1349 form.fields.push_back(field); 1350 test::CreateTestFormField("Email", "email", "", "text", &field); 1351 form.fields.push_back(field); 1352 test::CreateTestFormField("Phone", "phone", "", "text", &field); 1353 form.fields.push_back(field); 1354 1355 std::vector<FormData> forms(1, form); 1356 1357 // Expect a notification when the form is first seen. 1358 { 1359 EXPECT_CALL(*autofill_manager_->metric_logger(), 1360 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED)); 1361 autofill_manager_->OnFormsSeen(forms, TimeTicks(), 1362 autofill::NO_SPECIAL_FORMS_SEEN); 1363 } 1364 1365 // Simulate typing. 1366 { 1367 EXPECT_CALL(*autofill_manager_->metric_logger(), 1368 LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE)); 1369 autofill_manager_->OnTextFieldDidChange(form, form.fields.front(), 1370 TimeTicks()); 1371 } 1372 1373 // Simulate suggestions shown twice for a single edit (i.e. multiple 1374 // keystrokes in a single field). 1375 { 1376 EXPECT_CALL(*autofill_manager_->metric_logger(), 1377 LogUserHappinessMetric( 1378 AutofillMetrics::SUGGESTIONS_SHOWN)).Times(1); 1379 EXPECT_CALL(*autofill_manager_->metric_logger(), 1380 LogUserHappinessMetric( 1381 AutofillMetrics::SUGGESTIONS_SHOWN_ONCE)).Times(1); 1382 autofill_manager_->OnDidShowAutofillSuggestions(true); 1383 autofill_manager_->OnDidShowAutofillSuggestions(false); 1384 } 1385 1386 // Simulate suggestions shown for a different field. 1387 { 1388 EXPECT_CALL(*autofill_manager_->metric_logger(), 1389 LogUserHappinessMetric(AutofillMetrics::SUGGESTIONS_SHOWN)); 1390 EXPECT_CALL(*autofill_manager_->metric_logger(), 1391 LogUserHappinessMetric( 1392 AutofillMetrics::SUGGESTIONS_SHOWN_ONCE)).Times(0); 1393 autofill_manager_->OnDidShowAutofillSuggestions(true); 1394 } 1395 1396 // Simulate invoking autofill. 1397 { 1398 EXPECT_CALL(*autofill_manager_->metric_logger(), 1399 LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL)); 1400 EXPECT_CALL(*autofill_manager_->metric_logger(), 1401 LogUserHappinessMetric( 1402 AutofillMetrics::USER_DID_AUTOFILL_ONCE)); 1403 autofill_manager_->OnDidFillAutofillFormData(TimeTicks()); 1404 } 1405 1406 // Simulate editing an autofilled field. 1407 { 1408 EXPECT_CALL(*autofill_manager_->metric_logger(), 1409 LogUserHappinessMetric( 1410 AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD)); 1411 EXPECT_CALL(*autofill_manager_->metric_logger(), 1412 LogUserHappinessMetric( 1413 AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE)); 1414 PersonalDataManager::GUIDPair guid( 1415 "00000000-0000-0000-0000-000000000001", 0); 1416 PersonalDataManager::GUIDPair empty(std::string(), 0); 1417 autofill_manager_->OnFillAutofillFormData( 1418 0, form, form.fields.front(), 1419 autofill_manager_->PackGUIDs(empty, guid)); 1420 autofill_manager_->OnTextFieldDidChange(form, form.fields.front(), 1421 TimeTicks()); 1422 // Simulate a second keystroke; make sure we don't log the metric twice. 1423 autofill_manager_->OnTextFieldDidChange(form, form.fields.front(), 1424 TimeTicks()); 1425 } 1426 1427 // Simulate invoking autofill again. 1428 EXPECT_CALL(*autofill_manager_->metric_logger(), 1429 LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL)); 1430 EXPECT_CALL(*autofill_manager_->metric_logger(), 1431 LogUserHappinessMetric( 1432 AutofillMetrics::USER_DID_AUTOFILL_ONCE)).Times(0); 1433 autofill_manager_->OnDidFillAutofillFormData(TimeTicks()); 1434 1435 // Simulate editing another autofilled field. 1436 { 1437 EXPECT_CALL(*autofill_manager_->metric_logger(), 1438 LogUserHappinessMetric( 1439 AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD)); 1440 autofill_manager_->OnTextFieldDidChange(form, form.fields[1], TimeTicks()); 1441 } 1442} 1443 1444// Verify that we correctly log metrics tracking the duration of form fill. 1445TEST_F(AutofillMetricsTest, FormFillDuration) { 1446 // Load a fillable form. 1447 FormData form; 1448 form.name = ASCIIToUTF16("TestForm"); 1449 form.method = ASCIIToUTF16("POST"); 1450 form.origin = GURL("http://example.com/form.html"); 1451 form.action = GURL("http://example.com/submit.html"); 1452 form.user_submitted = true; 1453 1454 FormFieldData field; 1455 test::CreateTestFormField("Name", "name", "", "text", &field); 1456 form.fields.push_back(field); 1457 test::CreateTestFormField("Email", "email", "", "text", &field); 1458 form.fields.push_back(field); 1459 test::CreateTestFormField("Phone", "phone", "", "text", &field); 1460 form.fields.push_back(field); 1461 1462 std::vector<FormData> forms(1, form); 1463 1464 // Fill the field values for form submission. 1465 form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley"); 1466 form.fields[1].value = ASCIIToUTF16("theking@gmail.com"); 1467 form.fields[2].value = ASCIIToUTF16("12345678901"); 1468 1469 // Expect only form load metrics to be logged if the form is submitted without 1470 // user interaction. 1471 { 1472 EXPECT_CALL(*autofill_manager_->metric_logger(), 1473 LogFormFillDurationFromLoadWithAutofill(_)).Times(0); 1474 EXPECT_CALL(*autofill_manager_->metric_logger(), 1475 LogFormFillDurationFromLoadWithoutAutofill( 1476 TimeDelta::FromInternalValue(16))); 1477 EXPECT_CALL(*autofill_manager_->metric_logger(), 1478 LogFormFillDurationFromInteractionWithAutofill(_)).Times(0); 1479 EXPECT_CALL(*autofill_manager_->metric_logger(), 1480 LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0); 1481 autofill_manager_->OnFormsSeen( 1482 forms, TimeTicks::FromInternalValue(1), 1483 autofill::NO_SPECIAL_FORMS_SEEN); 1484 autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17)); 1485 autofill_manager_->Reset(); 1486 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 1487 } 1488 1489 // Expect metric to be logged if the user manually edited a form field. 1490 { 1491 EXPECT_CALL(*autofill_manager_->metric_logger(), 1492 LogFormFillDurationFromLoadWithAutofill(_)).Times(0); 1493 EXPECT_CALL(*autofill_manager_->metric_logger(), 1494 LogFormFillDurationFromLoadWithoutAutofill( 1495 TimeDelta::FromInternalValue(16))); 1496 EXPECT_CALL(*autofill_manager_->metric_logger(), 1497 LogFormFillDurationFromInteractionWithAutofill(_)).Times(0); 1498 EXPECT_CALL(*autofill_manager_->metric_logger(), 1499 LogFormFillDurationFromInteractionWithoutAutofill( 1500 TimeDelta::FromInternalValue(14))); 1501 autofill_manager_->OnFormsSeen( 1502 forms, TimeTicks::FromInternalValue(1), 1503 autofill::NO_SPECIAL_FORMS_SEEN); 1504 autofill_manager_->OnTextFieldDidChange(form, form.fields.front(), 1505 TimeTicks::FromInternalValue(3)); 1506 autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17)); 1507 autofill_manager_->Reset(); 1508 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 1509 } 1510 1511 // Expect metric to be logged if the user autofilled the form. 1512 form.fields[0].is_autofilled = true; 1513 { 1514 EXPECT_CALL(*autofill_manager_->metric_logger(), 1515 LogFormFillDurationFromLoadWithAutofill( 1516 TimeDelta::FromInternalValue(16))); 1517 EXPECT_CALL(*autofill_manager_->metric_logger(), 1518 LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0); 1519 EXPECT_CALL(*autofill_manager_->metric_logger(), 1520 LogFormFillDurationFromInteractionWithAutofill( 1521 TimeDelta::FromInternalValue(12))); 1522 EXPECT_CALL(*autofill_manager_->metric_logger(), 1523 LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0); 1524 autofill_manager_->OnFormsSeen( 1525 forms, TimeTicks::FromInternalValue(1), 1526 autofill::NO_SPECIAL_FORMS_SEEN); 1527 autofill_manager_->OnDidFillAutofillFormData( 1528 TimeTicks::FromInternalValue(5)); 1529 autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17)); 1530 autofill_manager_->Reset(); 1531 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 1532 } 1533 1534 // Expect metric to be logged if the user both manually filled some fields 1535 // and autofilled others. Messages can arrive out of order, so make sure they 1536 // take precedence appropriately. 1537 { 1538 EXPECT_CALL(*autofill_manager_->metric_logger(), 1539 LogFormFillDurationFromLoadWithAutofill( 1540 TimeDelta::FromInternalValue(16))); 1541 EXPECT_CALL(*autofill_manager_->metric_logger(), 1542 LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0); 1543 EXPECT_CALL(*autofill_manager_->metric_logger(), 1544 LogFormFillDurationFromInteractionWithAutofill( 1545 TimeDelta::FromInternalValue(14))); 1546 EXPECT_CALL(*autofill_manager_->metric_logger(), 1547 LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0); 1548 autofill_manager_->OnFormsSeen( 1549 forms, TimeTicks::FromInternalValue(1), 1550 autofill::NO_SPECIAL_FORMS_SEEN); 1551 autofill_manager_->OnDidFillAutofillFormData( 1552 TimeTicks::FromInternalValue(5)); 1553 autofill_manager_->OnTextFieldDidChange(form, form.fields.front(), 1554 TimeTicks::FromInternalValue(3)); 1555 autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17)); 1556 autofill_manager_->Reset(); 1557 Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger()); 1558 } 1559} 1560 1561} // namespace autofill 1562