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/prefs/pref_service.h"
12#include "base/run_loop.h"
13#include "base/strings/string16.h"
14#include "base/strings/utf_string_conversions.h"
15#include "base/time/time.h"
16#include "components/autofill/core/browser/autofill_external_delegate.h"
17#include "components/autofill/core/browser/autofill_manager.h"
18#include "components/autofill/core/browser/autofill_test_utils.h"
19#include "components/autofill/core/browser/personal_data_manager.h"
20#include "components/autofill/core/browser/test_autofill_client.h"
21#include "components/autofill/core/browser/test_autofill_driver.h"
22#include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
23#include "components/autofill/core/common/form_data.h"
24#include "components/autofill/core/common/form_field_data.h"
25#include "components/webdata/common/web_data_results.h"
26#include "testing/gmock/include/gmock/gmock.h"
27#include "testing/gtest/include/gtest/gtest.h"
28#include "ui/gfx/rect.h"
29#include "url/gurl.h"
30
31using base::ASCIIToUTF16;
32using base::TimeDelta;
33using base::TimeTicks;
34using testing::_;
35using testing::AnyNumber;
36using testing::Mock;
37
38namespace autofill {
39
40namespace {
41
42class MockAutofillMetrics : public AutofillMetrics {
43 public:
44  MockAutofillMetrics() {}
45  MOCK_CONST_METHOD1(LogCreditCardInfoBarMetric, void(InfoBarMetric metric));
46  MOCK_CONST_METHOD1(LogDeveloperEngagementMetric,
47                     void(DeveloperEngagementMetric metric));
48  MOCK_CONST_METHOD2(LogHeuristicTypePrediction,
49                     void(FieldTypeQualityMetric metric,
50                          ServerFieldType field_type));
51  MOCK_CONST_METHOD2(LogOverallTypePrediction,
52                     void(FieldTypeQualityMetric metric,
53                          ServerFieldType field_type));
54  MOCK_CONST_METHOD2(LogServerTypePrediction,
55                     void(FieldTypeQualityMetric metric,
56                          ServerFieldType field_type));
57  MOCK_CONST_METHOD1(LogServerQueryMetric, void(ServerQueryMetric metric));
58  MOCK_CONST_METHOD1(LogUserHappinessMetric, void(UserHappinessMetric metric));
59  MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithAutofill,
60                     void(const TimeDelta& duration));
61  MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithoutAutofill,
62                     void(const TimeDelta& duration));
63  MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithAutofill,
64                     void(const TimeDelta& duration));
65  MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithoutAutofill,
66                     void(const TimeDelta& duration));
67  MOCK_CONST_METHOD1(LogIsAutofillEnabledAtPageLoad, void(bool enabled));
68  MOCK_CONST_METHOD1(LogIsAutofillEnabledAtStartup, void(bool enabled));
69  MOCK_CONST_METHOD1(LogStoredProfileCount, void(size_t num_profiles));
70  MOCK_CONST_METHOD1(LogAddressSuggestionsCount, void(size_t num_suggestions));
71
72 private:
73  DISALLOW_COPY_AND_ASSIGN(MockAutofillMetrics);
74};
75
76class TestPersonalDataManager : public PersonalDataManager {
77 public:
78  TestPersonalDataManager()
79      : PersonalDataManager("en-US"),
80        autofill_enabled_(true) {
81    set_metric_logger(new testing::NiceMock<MockAutofillMetrics>());
82    CreateTestAutofillProfiles(&web_profiles_);
83  }
84
85  using PersonalDataManager::set_database;
86  using PersonalDataManager::SetPrefService;
87
88  // Overridden to avoid a trip to the database. This should be a no-op except
89  // for the side-effect of logging the profile count.
90  virtual void LoadProfiles() OVERRIDE {
91    std::vector<AutofillProfile*> profiles;
92    web_profiles_.release(&profiles);
93    WDResult<std::vector<AutofillProfile*> > result(AUTOFILL_PROFILES_RESULT,
94                                                    profiles);
95    ReceiveLoadedProfiles(0, &result);
96  }
97
98  // Overridden to avoid a trip to the database.
99  virtual void LoadCreditCards() OVERRIDE {}
100
101  const MockAutofillMetrics* metric_logger() const {
102    return static_cast<const MockAutofillMetrics*>(
103        PersonalDataManager::metric_logger());
104  }
105
106  void set_autofill_enabled(bool autofill_enabled) {
107    autofill_enabled_ = autofill_enabled;
108  }
109
110  virtual bool IsAutofillEnabled() const OVERRIDE {
111    return autofill_enabled_;
112  }
113
114  MOCK_METHOD1(SaveImportedCreditCard,
115               std::string(const CreditCard& imported_credit_card));
116
117 private:
118  void CreateTestAutofillProfiles(ScopedVector<AutofillProfile>* profiles) {
119    AutofillProfile* profile = new AutofillProfile;
120    test::SetProfileInfo(profile, "Elvis", "Aaron",
121                         "Presley", "theking@gmail.com", "RCA",
122                         "3734 Elvis Presley Blvd.", "Apt. 10",
123                         "Memphis", "Tennessee", "38116", "US",
124                         "12345678901");
125    profile->set_guid("00000000-0000-0000-0000-000000000001");
126    profiles->push_back(profile);
127    profile = new AutofillProfile;
128    test::SetProfileInfo(profile, "Charles", "Hardin",
129                         "Holley", "buddy@gmail.com", "Decca",
130                         "123 Apple St.", "unit 6", "Lubbock",
131                         "Texas", "79401", "US", "2345678901");
132    profile->set_guid("00000000-0000-0000-0000-000000000002");
133    profiles->push_back(profile);
134  }
135
136  bool autofill_enabled_;
137
138  DISALLOW_COPY_AND_ASSIGN(TestPersonalDataManager);
139};
140
141class TestFormStructure : public FormStructure {
142 public:
143  explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
144  virtual ~TestFormStructure() {}
145
146  void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types,
147                     const std::vector<ServerFieldType>& server_types) {
148    ASSERT_EQ(field_count(), heuristic_types.size());
149    ASSERT_EQ(field_count(), server_types.size());
150
151    for (size_t i = 0; i < field_count(); ++i) {
152      AutofillField* form_field = field(i);
153      ASSERT_TRUE(form_field);
154      form_field->set_heuristic_type(heuristic_types[i]);
155      form_field->set_server_type(server_types[i]);
156    }
157
158    UpdateAutofillCount();
159  }
160
161 private:
162  DISALLOW_COPY_AND_ASSIGN(TestFormStructure);
163};
164
165class TestAutofillManager : public AutofillManager {
166 public:
167  TestAutofillManager(AutofillDriver* driver,
168                      AutofillClient* autofill_client,
169                      TestPersonalDataManager* personal_manager)
170      : AutofillManager(driver, autofill_client, personal_manager),
171        autofill_enabled_(true) {
172    set_metric_logger(new testing::NiceMock<MockAutofillMetrics>);
173  }
174  virtual ~TestAutofillManager() {}
175
176  virtual bool IsAutofillEnabled() const OVERRIDE { return autofill_enabled_; }
177
178  void set_autofill_enabled(bool autofill_enabled) {
179    autofill_enabled_ = autofill_enabled;
180  }
181
182  MockAutofillMetrics* metric_logger() {
183    return static_cast<MockAutofillMetrics*>(const_cast<AutofillMetrics*>(
184        AutofillManager::metric_logger()));
185  }
186
187  void AddSeenForm(const FormData& form,
188                   const std::vector<ServerFieldType>& heuristic_types,
189                   const std::vector<ServerFieldType>& server_types) {
190    FormData empty_form = form;
191    for (size_t i = 0; i < empty_form.fields.size(); ++i) {
192      empty_form.fields[i].value = base::string16();
193    }
194
195    // |form_structure| will be owned by |form_structures()|.
196    TestFormStructure* form_structure = new TestFormStructure(empty_form);
197    form_structure->SetFieldTypes(heuristic_types, server_types);
198    form_structures()->push_back(form_structure);
199  }
200
201  void FormSubmitted(const FormData& form, const TimeTicks& timestamp) {
202    run_loop_.reset(new base::RunLoop());
203    if (!OnFormSubmitted(form, timestamp))
204      return;
205
206    // Wait for the asynchronous FormSubmitted() call to complete.
207    run_loop_->Run();
208  }
209
210  virtual void UploadFormDataAsyncCallback(
211      const FormStructure* submitted_form,
212      const base::TimeTicks& load_time,
213      const base::TimeTicks& interaction_time,
214      const base::TimeTicks& submission_time) OVERRIDE {
215    run_loop_->Quit();
216
217    AutofillManager::UploadFormDataAsyncCallback(submitted_form,
218                                                 load_time,
219                                                 interaction_time,
220                                                 submission_time);
221  }
222
223 private:
224  bool autofill_enabled_;
225  scoped_ptr<base::RunLoop> run_loop_;
226
227  DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
228};
229
230}  // namespace
231
232class AutofillMetricsTest : public testing::Test {
233 public:
234  virtual ~AutofillMetricsTest();
235
236  virtual void SetUp() OVERRIDE;
237  virtual void TearDown() OVERRIDE;
238
239 protected:
240  base::MessageLoop message_loop_;
241  TestAutofillClient autofill_client_;
242  scoped_ptr<TestAutofillDriver> autofill_driver_;
243  scoped_ptr<TestAutofillManager> autofill_manager_;
244  scoped_ptr<TestPersonalDataManager> personal_data_;
245  scoped_ptr<AutofillExternalDelegate> external_delegate_;
246};
247
248AutofillMetricsTest::~AutofillMetricsTest() {
249  // Order of destruction is important as AutofillManager relies on
250  // PersonalDataManager to be around when it gets destroyed.
251  autofill_manager_.reset();
252}
253
254void AutofillMetricsTest::SetUp() {
255  autofill_client_.SetPrefs(test::PrefServiceForTesting());
256
257  // Ensure Mac OS X does not pop up a modal dialog for the Address Book.
258  test::DisableSystemServices(autofill_client_.GetPrefs());
259
260  personal_data_.reset(new TestPersonalDataManager());
261  personal_data_->set_database(autofill_client_.GetDatabase());
262  personal_data_->SetPrefService(autofill_client_.GetPrefs());
263  autofill_driver_.reset(new TestAutofillDriver());
264  autofill_manager_.reset(new TestAutofillManager(
265      autofill_driver_.get(), &autofill_client_, personal_data_.get()));
266
267  external_delegate_.reset(new AutofillExternalDelegate(
268      autofill_manager_.get(),
269      autofill_driver_.get()));
270  autofill_manager_->SetExternalDelegate(external_delegate_.get());
271}
272
273void AutofillMetricsTest::TearDown() {
274  // Order of destruction is important as AutofillManager relies on
275  // PersonalDataManager to be around when it gets destroyed.
276  autofill_manager_.reset();
277  autofill_driver_.reset();
278  personal_data_.reset();
279}
280
281// Test that we log quality metrics appropriately.
282TEST_F(AutofillMetricsTest, QualityMetrics) {
283  // Set up our form data.
284  FormData form;
285  form.name = ASCIIToUTF16("TestForm");
286  form.method = ASCIIToUTF16("POST");
287  form.origin = GURL("http://example.com/form.html");
288  form.action = GURL("http://example.com/submit.html");
289  form.user_submitted = true;
290
291  std::vector<ServerFieldType> heuristic_types, server_types;
292  FormFieldData field;
293
294  test::CreateTestFormField(
295      "Autofilled", "autofilled", "Elvis Aaron Presley", "text", &field);
296  field.is_autofilled = true;
297  form.fields.push_back(field);
298  heuristic_types.push_back(NAME_FULL);
299  server_types.push_back(NAME_FIRST);
300
301  test::CreateTestFormField(
302      "Autofill Failed", "autofillfailed", "buddy@gmail.com", "text", &field);
303  field.is_autofilled = false;
304  form.fields.push_back(field);
305  heuristic_types.push_back(PHONE_HOME_NUMBER);
306  server_types.push_back(EMAIL_ADDRESS);
307
308  test::CreateTestFormField("Empty", "empty", "", "text", &field);
309  field.is_autofilled = false;
310  form.fields.push_back(field);
311  heuristic_types.push_back(NAME_FULL);
312  server_types.push_back(NAME_FIRST);
313
314  test::CreateTestFormField("Unknown", "unknown", "garbage", "text", &field);
315  field.is_autofilled = false;
316  form.fields.push_back(field);
317  heuristic_types.push_back(PHONE_HOME_NUMBER);
318  server_types.push_back(EMAIL_ADDRESS);
319
320  test::CreateTestFormField("Select", "select", "USA", "select-one", &field);
321  field.is_autofilled = false;
322  form.fields.push_back(field);
323  heuristic_types.push_back(UNKNOWN_TYPE);
324  server_types.push_back(NO_SERVER_DATA);
325
326  test::CreateTestFormField("Phone", "phone", "2345678901", "tel", &field);
327  field.is_autofilled = true;
328  form.fields.push_back(field);
329  heuristic_types.push_back(PHONE_HOME_CITY_AND_NUMBER);
330  server_types.push_back(PHONE_HOME_WHOLE_NUMBER);
331
332  // Simulate having seen this form on page load.
333  autofill_manager_->AddSeenForm(form, heuristic_types, server_types);
334
335  // Establish our expectations.
336  ::testing::InSequence dummy;
337  // Autofilled field
338  EXPECT_CALL(*autofill_manager_->metric_logger(),
339              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
340                  NAME_FULL));
341  EXPECT_CALL(*autofill_manager_->metric_logger(),
342              LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH,
343                  NAME_FULL));
344  EXPECT_CALL(*autofill_manager_->metric_logger(),
345              LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH,
346                  NAME_FULL));
347  // Non-autofilled field for which we had data
348  EXPECT_CALL(*autofill_manager_->metric_logger(),
349              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MISMATCH,
350                  EMAIL_ADDRESS));
351  EXPECT_CALL(*autofill_manager_->metric_logger(),
352              LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
353                  EMAIL_ADDRESS));
354  EXPECT_CALL(*autofill_manager_->metric_logger(),
355              LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
356                  EMAIL_ADDRESS));
357  // Empty field
358  // Unknown field
359  // <select> field
360  EXPECT_CALL(*autofill_manager_->metric_logger(),
361              LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
362                  ADDRESS_HOME_COUNTRY));
363  EXPECT_CALL(*autofill_manager_->metric_logger(),
364              LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
365                  ADDRESS_HOME_COUNTRY));
366  EXPECT_CALL(*autofill_manager_->metric_logger(),
367              LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
368                  ADDRESS_HOME_COUNTRY));
369  // Phone field
370  EXPECT_CALL(*autofill_manager_->metric_logger(),
371              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
372                  PHONE_HOME_WHOLE_NUMBER));
373  EXPECT_CALL(*autofill_manager_->metric_logger(),
374              LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
375                  PHONE_HOME_WHOLE_NUMBER));
376  EXPECT_CALL(*autofill_manager_->metric_logger(),
377              LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
378                  PHONE_HOME_WHOLE_NUMBER));
379  EXPECT_CALL(*autofill_manager_->metric_logger(),
380              LogUserHappinessMetric(
381                  AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME));
382
383  // Simulate form submission.
384  EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form,
385                                                           TimeTicks::Now()));
386}
387
388// Test that we behave sanely when the cached form differs from the submitted
389// one.
390TEST_F(AutofillMetricsTest, SaneMetricsWithCacheMismatch) {
391  // Set up our form data.
392  FormData form;
393  form.name = ASCIIToUTF16("TestForm");
394  form.method = ASCIIToUTF16("POST");
395  form.origin = GURL("http://example.com/form.html");
396  form.action = GURL("http://example.com/submit.html");
397  form.user_submitted = true;
398
399  std::vector<ServerFieldType> heuristic_types, server_types;
400
401  FormFieldData field;
402  test::CreateTestFormField(
403      "Both match", "match", "Elvis Aaron Presley", "text", &field);
404  field.is_autofilled = true;
405  form.fields.push_back(field);
406  heuristic_types.push_back(NAME_FULL);
407  server_types.push_back(NAME_FULL);
408  test::CreateTestFormField(
409      "Both mismatch", "mismatch", "buddy@gmail.com", "text", &field);
410  field.is_autofilled = false;
411  form.fields.push_back(field);
412  heuristic_types.push_back(PHONE_HOME_NUMBER);
413  server_types.push_back(PHONE_HOME_NUMBER);
414  test::CreateTestFormField(
415      "Only heuristics match", "mixed", "Memphis", "text", &field);
416  field.is_autofilled = false;
417  form.fields.push_back(field);
418  heuristic_types.push_back(ADDRESS_HOME_CITY);
419  server_types.push_back(PHONE_HOME_NUMBER);
420  test::CreateTestFormField("Unknown", "unknown", "garbage", "text", &field);
421  field.is_autofilled = false;
422  form.fields.push_back(field);
423  heuristic_types.push_back(UNKNOWN_TYPE);
424  server_types.push_back(UNKNOWN_TYPE);
425
426  // Simulate having seen this form with the desired heuristic and server types.
427  // |form_structure| will be owned by |autofill_manager_|.
428  autofill_manager_->AddSeenForm(form, heuristic_types, server_types);
429
430
431  // Add a field and re-arrange the remaining form fields before submitting.
432  std::vector<FormFieldData> cached_fields = form.fields;
433  form.fields.clear();
434  test::CreateTestFormField(
435      "New field", "new field", "Tennessee", "text", &field);
436  form.fields.push_back(field);
437  form.fields.push_back(cached_fields[2]);
438  form.fields.push_back(cached_fields[1]);
439  form.fields.push_back(cached_fields[3]);
440  form.fields.push_back(cached_fields[0]);
441
442  // Establish our expectations.
443  ::testing::InSequence dummy;
444  // New field
445  EXPECT_CALL(*autofill_manager_->metric_logger(),
446              LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
447                  ADDRESS_HOME_STATE));
448  EXPECT_CALL(*autofill_manager_->metric_logger(),
449              LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
450                  ADDRESS_HOME_STATE));
451  EXPECT_CALL(*autofill_manager_->metric_logger(),
452              LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
453                  ADDRESS_HOME_STATE));
454  // Only heuristics match
455  EXPECT_CALL(*autofill_manager_->metric_logger(),
456              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
457                  ADDRESS_HOME_CITY));
458  EXPECT_CALL(*autofill_manager_->metric_logger(),
459              LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH,
460                  ADDRESS_HOME_CITY));
461  EXPECT_CALL(*autofill_manager_->metric_logger(),
462              LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH,
463                  ADDRESS_HOME_CITY));
464  // Both mismatch
465  EXPECT_CALL(*autofill_manager_->metric_logger(),
466              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MISMATCH,
467                  EMAIL_ADDRESS));
468  EXPECT_CALL(*autofill_manager_->metric_logger(),
469              LogServerTypePrediction(AutofillMetrics::TYPE_MISMATCH,
470                  EMAIL_ADDRESS));
471  EXPECT_CALL(*autofill_manager_->metric_logger(),
472              LogOverallTypePrediction(AutofillMetrics::TYPE_MISMATCH,
473                  EMAIL_ADDRESS));
474  // Unknown
475  // Both match
476  EXPECT_CALL(*autofill_manager_->metric_logger(),
477              LogHeuristicTypePrediction(AutofillMetrics::TYPE_MATCH,
478                  NAME_FULL));
479  EXPECT_CALL(*autofill_manager_->metric_logger(),
480              LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
481                  NAME_FULL));
482  EXPECT_CALL(*autofill_manager_->metric_logger(),
483              LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
484                  NAME_FULL));
485
486  // Simulate form submission.
487  EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(form,
488                                                           TimeTicks::Now()));
489}
490
491// Verify that we correctly log metrics regarding developer engagement.
492TEST_F(AutofillMetricsTest, DeveloperEngagement) {
493  // Start with a non-fillable form.
494  FormData form;
495  form.name = ASCIIToUTF16("TestForm");
496  form.method = ASCIIToUTF16("POST");
497  form.origin = GURL("http://example.com/form.html");
498  form.action = GURL("http://example.com/submit.html");
499
500  FormFieldData field;
501  test::CreateTestFormField("Name", "name", "", "text", &field);
502  form.fields.push_back(field);
503  test::CreateTestFormField("Email", "email", "", "text", &field);
504  form.fields.push_back(field);
505
506  std::vector<FormData> forms(1, form);
507
508  // Ensure no metrics are logged when loading a non-fillable form.
509  {
510    EXPECT_CALL(*autofill_manager_->metric_logger(),
511                LogDeveloperEngagementMetric(_)).Times(0);
512    autofill_manager_->OnFormsSeen(forms, TimeTicks());
513    autofill_manager_->Reset();
514    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
515  }
516
517  // Add another field to the form, so that it becomes fillable.
518  test::CreateTestFormField("Phone", "phone", "", "text", &field);
519  forms.back().fields.push_back(field);
520
521  // Expect only the "form parsed" metric to be logged; no metrics about
522  // author-specified field type hints.
523  {
524    EXPECT_CALL(
525        *autofill_manager_->metric_logger(),
526        LogDeveloperEngagementMetric(
527            AutofillMetrics::FILLABLE_FORM_PARSED)).Times(1);
528    EXPECT_CALL(
529        *autofill_manager_->metric_logger(),
530        LogDeveloperEngagementMetric(
531            AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS)).Times(0);
532    autofill_manager_->OnFormsSeen(forms, TimeTicks());
533    autofill_manager_->Reset();
534    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
535  }
536
537  // Add some fields with an author-specified field type to the form.
538  // We need to add at least three fields, because a form must have at least
539  // three fillable fields to be considered to be autofillable; and if at least
540  // one field specifies an explicit type hint, we don't apply any of our usual
541  // local heuristics to detect field types in the rest of the form.
542  test::CreateTestFormField("", "", "", "text", &field);
543  field.autocomplete_attribute = "given-name";
544  forms.back().fields.push_back(field);
545  test::CreateTestFormField("", "", "", "text", &field);
546  field.autocomplete_attribute = "email";
547  forms.back().fields.push_back(field);
548  test::CreateTestFormField("", "", "", "text", &field);
549  field.autocomplete_attribute = "address-line1";
550  forms.back().fields.push_back(field);
551
552  // Expect both the "form parsed" metric and the author-specified field type
553  // hints metric to be logged.
554  {
555    EXPECT_CALL(
556        *autofill_manager_->metric_logger(),
557        LogDeveloperEngagementMetric(
558            AutofillMetrics::FILLABLE_FORM_PARSED)).Times(1);
559    EXPECT_CALL(
560        *autofill_manager_->metric_logger(),
561        LogDeveloperEngagementMetric(
562            AutofillMetrics::FILLABLE_FORM_CONTAINS_TYPE_HINTS)).Times(1);
563    autofill_manager_->OnFormsSeen(forms, TimeTicks());
564    autofill_manager_->Reset();
565    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
566  }
567}
568
569// Test that the profile count is logged correctly.
570TEST_F(AutofillMetricsTest, StoredProfileCount) {
571  // The metric should be logged when the profiles are first loaded.
572  EXPECT_CALL(*personal_data_->metric_logger(),
573              LogStoredProfileCount(2)).Times(1);
574  personal_data_->LoadProfiles();
575
576  // The metric should only be logged once.
577  EXPECT_CALL(*personal_data_->metric_logger(),
578              LogStoredProfileCount(::testing::_)).Times(0);
579  personal_data_->LoadProfiles();
580}
581
582// Test that we correctly log when Autofill is enabled.
583TEST_F(AutofillMetricsTest, AutofillIsEnabledAtStartup) {
584  personal_data_->set_autofill_enabled(true);
585  EXPECT_CALL(*personal_data_->metric_logger(),
586              LogIsAutofillEnabledAtStartup(true)).Times(1);
587  personal_data_->Init(
588      autofill_client_.GetDatabase(), autofill_client_.GetPrefs(), false);
589}
590
591// Test that we correctly log when Autofill is disabled.
592TEST_F(AutofillMetricsTest, AutofillIsDisabledAtStartup) {
593  personal_data_->set_autofill_enabled(false);
594  EXPECT_CALL(*personal_data_->metric_logger(),
595              LogIsAutofillEnabledAtStartup(false)).Times(1);
596  personal_data_->Init(
597      autofill_client_.GetDatabase(), autofill_client_.GetPrefs(), false);
598}
599
600// Test that we log the number of Autofill suggestions when filling a form.
601TEST_F(AutofillMetricsTest, AddressSuggestionsCount) {
602  // Set up our form data.
603  FormData form;
604  form.name = ASCIIToUTF16("TestForm");
605  form.method = ASCIIToUTF16("POST");
606  form.origin = GURL("http://example.com/form.html");
607  form.action = GURL("http://example.com/submit.html");
608  form.user_submitted = true;
609
610  FormFieldData field;
611  std::vector<ServerFieldType> field_types;
612  test::CreateTestFormField("Name", "name", "", "text", &field);
613  form.fields.push_back(field);
614  field_types.push_back(NAME_FULL);
615  test::CreateTestFormField("Email", "email", "", "email", &field);
616  form.fields.push_back(field);
617  field_types.push_back(EMAIL_ADDRESS);
618  test::CreateTestFormField("Phone", "phone", "", "tel", &field);
619  form.fields.push_back(field);
620  field_types.push_back(PHONE_HOME_NUMBER);
621
622  // Simulate having seen this form on page load.
623  // |form_structure| will be owned by |autofill_manager_|.
624  autofill_manager_->AddSeenForm(form, field_types, field_types);
625
626  // Establish our expectations.
627  ::testing::InSequence dummy;
628  EXPECT_CALL(*autofill_manager_->metric_logger(),
629              LogAddressSuggestionsCount(2)).Times(1);
630
631  // Simulate activating the autofill popup for the phone field.
632  autofill_manager_->OnQueryFormFieldAutofill(
633      0, form, field, gfx::Rect(), false);
634
635  // Simulate activating the autofill popup for the email field after typing.
636  // No new metric should be logged, since we're still on the same page.
637  test::CreateTestFormField("Email", "email", "b", "email", &field);
638  autofill_manager_->OnQueryFormFieldAutofill(
639      0, form, field, gfx::Rect(), false);
640
641  // Reset the autofill manager state.
642  autofill_manager_->Reset();
643  autofill_manager_->AddSeenForm(form, field_types, field_types);
644
645  // Establish our expectations.
646  EXPECT_CALL(*autofill_manager_->metric_logger(),
647              LogAddressSuggestionsCount(1)).Times(1);
648
649  // Simulate activating the autofill popup for the email field after typing.
650  autofill_manager_->OnQueryFormFieldAutofill(
651      0, form, field, gfx::Rect(), false);
652
653  // Reset the autofill manager state again.
654  autofill_manager_->Reset();
655  autofill_manager_->AddSeenForm(form, field_types, field_types);
656
657  // Establish our expectations.
658  EXPECT_CALL(*autofill_manager_->metric_logger(),
659              LogAddressSuggestionsCount(::testing::_)).Times(0);
660
661  // Simulate activating the autofill popup for the email field after typing.
662  form.fields[0].is_autofilled = true;
663  autofill_manager_->OnQueryFormFieldAutofill(
664      0, form, field, gfx::Rect(), false);
665}
666
667// Test that we log whether Autofill is enabled when filling a form.
668TEST_F(AutofillMetricsTest, AutofillIsEnabledAtPageLoad) {
669  // Establish our expectations.
670  ::testing::InSequence dummy;
671  EXPECT_CALL(*autofill_manager_->metric_logger(),
672              LogIsAutofillEnabledAtPageLoad(true)).Times(1);
673
674  autofill_manager_->set_autofill_enabled(true);
675  autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks());
676
677  // Reset the autofill manager state.
678  autofill_manager_->Reset();
679
680  // Establish our expectations.
681  EXPECT_CALL(*autofill_manager_->metric_logger(),
682              LogIsAutofillEnabledAtPageLoad(false)).Times(1);
683
684  autofill_manager_->set_autofill_enabled(false);
685  autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks());
686}
687
688// Verify that we correctly log user happiness metrics dealing with form loading
689// and form submission.
690TEST_F(AutofillMetricsTest, UserHappinessFormLoadAndSubmission) {
691  // Start with a form with insufficiently many fields.
692  FormData form;
693  form.name = ASCIIToUTF16("TestForm");
694  form.method = ASCIIToUTF16("POST");
695  form.origin = GURL("http://example.com/form.html");
696  form.action = GURL("http://example.com/submit.html");
697  form.user_submitted = true;
698
699  FormFieldData field;
700  test::CreateTestFormField("Name", "name", "", "text", &field);
701  form.fields.push_back(field);
702  test::CreateTestFormField("Email", "email", "", "text", &field);
703  form.fields.push_back(field);
704
705  std::vector<FormData> forms(1, form);
706
707  // Expect no notifications when the form is first seen.
708  {
709    EXPECT_CALL(*autofill_manager_->metric_logger(),
710                LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED)).Times(0);
711    autofill_manager_->OnFormsSeen(forms, TimeTicks());
712  }
713
714
715  // Expect no notifications when the form is submitted.
716  {
717    EXPECT_CALL(
718        *autofill_manager_->metric_logger(),
719        LogUserHappinessMetric(
720            AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL)).Times(0);
721    EXPECT_CALL(
722        *autofill_manager_->metric_logger(),
723        LogUserHappinessMetric(
724            AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME)).Times(0);
725    EXPECT_CALL(
726        *autofill_manager_->metric_logger(),
727        LogUserHappinessMetric(
728            AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE)).Times(0);
729    EXPECT_CALL(
730        *autofill_manager_->metric_logger(),
731        LogUserHappinessMetric(
732            AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)).Times(0);
733    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
734  }
735
736  // Add more fields to the form.
737  test::CreateTestFormField("Phone", "phone", "", "text", &field);
738  form.fields.push_back(field);
739  test::CreateTestFormField("Unknown", "unknown", "", "text", &field);
740  form.fields.push_back(field);
741  forms.front() = form;
742
743  // Expect a notification when the form is first seen.
744  {
745    EXPECT_CALL(*autofill_manager_->metric_logger(),
746                LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED));
747    autofill_manager_->OnFormsSeen(forms, TimeTicks());
748  }
749
750  // Expect a notification when the form is submitted.
751  {
752    EXPECT_CALL(*autofill_manager_->metric_logger(),
753                LogUserHappinessMetric(
754                    AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
755    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
756  }
757
758  // Fill in two of the fields.
759  form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
760  form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
761  forms.front() = form;
762
763  // Expect a notification when the form is submitted.
764  {
765    EXPECT_CALL(*autofill_manager_->metric_logger(),
766                LogUserHappinessMetric(
767                    AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
768    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
769  }
770
771  // Fill in the third field.
772  form.fields[2].value = ASCIIToUTF16("12345678901");
773  forms.front() = form;
774
775  // Expect notifications when the form is submitted.
776  {
777    EXPECT_CALL(*autofill_manager_->metric_logger(),
778                LogUserHappinessMetric(
779                    AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE));
780    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
781  }
782
783
784  // Mark one of the fields as autofilled.
785  form.fields[1].is_autofilled = true;
786  forms.front() = form;
787
788  // Expect notifications when the form is submitted.
789  {
790    EXPECT_CALL(*autofill_manager_->metric_logger(),
791                LogUserHappinessMetric(
792                    AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME));
793    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
794  }
795
796  // Mark all of the fillable fields as autofilled.
797  form.fields[0].is_autofilled = true;
798  form.fields[2].is_autofilled = true;
799  forms.front() = form;
800
801  // Expect notifications when the form is submitted.
802  {
803    EXPECT_CALL(*autofill_manager_->metric_logger(),
804                LogUserHappinessMetric(
805                    AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL));
806    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
807  }
808
809  // Clear out the third field's value.
810  form.fields[2].value = base::string16();
811  forms.front() = form;
812
813  // Expect notifications when the form is submitted.
814  {
815    EXPECT_CALL(*autofill_manager_->metric_logger(),
816                LogUserHappinessMetric(
817                    AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
818    autofill_manager_->FormSubmitted(form, TimeTicks::Now());
819  }
820}
821
822// Verify that we correctly log user happiness metrics dealing with form
823// interaction.
824TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) {
825  // Load a fillable form.
826  FormData form;
827  form.name = ASCIIToUTF16("TestForm");
828  form.method = ASCIIToUTF16("POST");
829  form.origin = GURL("http://example.com/form.html");
830  form.action = GURL("http://example.com/submit.html");
831  form.user_submitted = true;
832
833  FormFieldData field;
834  test::CreateTestFormField("Name", "name", "", "text", &field);
835  form.fields.push_back(field);
836  test::CreateTestFormField("Email", "email", "", "text", &field);
837  form.fields.push_back(field);
838  test::CreateTestFormField("Phone", "phone", "", "text", &field);
839  form.fields.push_back(field);
840
841  std::vector<FormData> forms(1, form);
842
843  // Expect a notification when the form is first seen.
844  {
845    EXPECT_CALL(*autofill_manager_->metric_logger(),
846                LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED));
847    autofill_manager_->OnFormsSeen(forms, TimeTicks());
848  }
849
850  // Simulate typing.
851  {
852    EXPECT_CALL(*autofill_manager_->metric_logger(),
853                LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE));
854    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
855                                            TimeTicks());
856  }
857
858  // Simulate suggestions shown twice for a single edit (i.e. multiple
859  // keystrokes in a single field).
860  {
861    EXPECT_CALL(*autofill_manager_->metric_logger(),
862                LogUserHappinessMetric(
863                    AutofillMetrics::SUGGESTIONS_SHOWN)).Times(1);
864    EXPECT_CALL(*autofill_manager_->metric_logger(),
865                LogUserHappinessMetric(
866                    AutofillMetrics::SUGGESTIONS_SHOWN_ONCE)).Times(1);
867    autofill_manager_->DidShowSuggestions(true);
868    autofill_manager_->DidShowSuggestions(false);
869  }
870
871  // Simulate suggestions shown for a different field.
872  {
873    EXPECT_CALL(*autofill_manager_->metric_logger(),
874                LogUserHappinessMetric(AutofillMetrics::SUGGESTIONS_SHOWN));
875    EXPECT_CALL(*autofill_manager_->metric_logger(),
876                LogUserHappinessMetric(
877                    AutofillMetrics::SUGGESTIONS_SHOWN_ONCE)).Times(0);
878    autofill_manager_->DidShowSuggestions(true);
879  }
880
881  // Simulate invoking autofill.
882  {
883    EXPECT_CALL(*autofill_manager_->metric_logger(),
884                LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL));
885    EXPECT_CALL(*autofill_manager_->metric_logger(),
886                LogUserHappinessMetric(
887                    AutofillMetrics::USER_DID_AUTOFILL_ONCE));
888    autofill_manager_->OnDidFillAutofillFormData(TimeTicks());
889  }
890
891  // Simulate editing an autofilled field.
892  {
893    EXPECT_CALL(*autofill_manager_->metric_logger(),
894                LogUserHappinessMetric(
895                    AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD));
896    EXPECT_CALL(*autofill_manager_->metric_logger(),
897                LogUserHappinessMetric(
898                    AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE));
899    PersonalDataManager::GUIDPair guid(
900        "00000000-0000-0000-0000-000000000001", 0);
901    PersonalDataManager::GUIDPair empty(std::string(), 0);
902    autofill_manager_->FillOrPreviewForm(
903        AutofillDriver::FORM_DATA_ACTION_FILL,
904        0, form, form.fields.front(),
905        autofill_manager_->PackGUIDs(empty, guid));
906    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
907                                            TimeTicks());
908    // Simulate a second keystroke; make sure we don't log the metric twice.
909    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
910                                            TimeTicks());
911  }
912
913  // Simulate invoking autofill again.
914  EXPECT_CALL(*autofill_manager_->metric_logger(),
915              LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL));
916  EXPECT_CALL(*autofill_manager_->metric_logger(),
917              LogUserHappinessMetric(
918                  AutofillMetrics::USER_DID_AUTOFILL_ONCE)).Times(0);
919  autofill_manager_->OnDidFillAutofillFormData(TimeTicks());
920
921  // Simulate editing another autofilled field.
922  {
923    EXPECT_CALL(*autofill_manager_->metric_logger(),
924                LogUserHappinessMetric(
925                    AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD));
926    autofill_manager_->OnTextFieldDidChange(form, form.fields[1], TimeTicks());
927  }
928}
929
930// Verify that we correctly log metrics tracking the duration of form fill.
931TEST_F(AutofillMetricsTest, FormFillDuration) {
932  // Load a fillable form.
933  FormData form;
934  form.name = ASCIIToUTF16("TestForm");
935  form.method = ASCIIToUTF16("POST");
936  form.origin = GURL("http://example.com/form.html");
937  form.action = GURL("http://example.com/submit.html");
938  form.user_submitted = true;
939
940  FormFieldData field;
941  test::CreateTestFormField("Name", "name", "", "text", &field);
942  form.fields.push_back(field);
943  test::CreateTestFormField("Email", "email", "", "text", &field);
944  form.fields.push_back(field);
945  test::CreateTestFormField("Phone", "phone", "", "text", &field);
946  form.fields.push_back(field);
947
948  std::vector<FormData> forms(1, form);
949
950  // Fill additional form.
951  FormData second_form = form;
952  test::CreateTestFormField("Second Phone", "second_phone", "", "text", &field);
953  second_form.fields.push_back(field);
954
955  std::vector<FormData> second_forms(1, second_form);
956
957  // Fill the field values for form submission.
958  form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
959  form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
960  form.fields[2].value = ASCIIToUTF16("12345678901");
961
962  // Fill the field values for form submission.
963  second_form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
964  second_form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
965  second_form.fields[2].value = ASCIIToUTF16("12345678901");
966  second_form.fields[3].value = ASCIIToUTF16("51512345678");
967
968  // Expect only form load metrics to be logged if the form is submitted without
969  // user interaction.
970  {
971    EXPECT_CALL(*autofill_manager_->metric_logger(),
972                LogFormFillDurationFromLoadWithAutofill(_)).Times(0);
973    EXPECT_CALL(*autofill_manager_->metric_logger(),
974                LogFormFillDurationFromLoadWithoutAutofill(
975                    TimeDelta::FromInternalValue(16)));
976    EXPECT_CALL(*autofill_manager_->metric_logger(),
977                LogFormFillDurationFromInteractionWithAutofill(_)).Times(0);
978    EXPECT_CALL(*autofill_manager_->metric_logger(),
979                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
980    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
981    autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
982    autofill_manager_->Reset();
983    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
984  }
985
986  // Expect metric to be logged if the user manually edited a form field.
987  {
988    EXPECT_CALL(*autofill_manager_->metric_logger(),
989                LogFormFillDurationFromLoadWithAutofill(_)).Times(0);
990    EXPECT_CALL(*autofill_manager_->metric_logger(),
991                LogFormFillDurationFromLoadWithoutAutofill(
992                    TimeDelta::FromInternalValue(16)));
993    EXPECT_CALL(*autofill_manager_->metric_logger(),
994                LogFormFillDurationFromInteractionWithAutofill(_)).Times(0);
995    EXPECT_CALL(*autofill_manager_->metric_logger(),
996                LogFormFillDurationFromInteractionWithoutAutofill(
997                    TimeDelta::FromInternalValue(14)));
998    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
999    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
1000                                            TimeTicks::FromInternalValue(3));
1001    autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
1002    autofill_manager_->Reset();
1003    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
1004  }
1005
1006  // Expect metric to be logged if the user autofilled the form.
1007  form.fields[0].is_autofilled = true;
1008  {
1009    EXPECT_CALL(*autofill_manager_->metric_logger(),
1010                LogFormFillDurationFromLoadWithAutofill(
1011                    TimeDelta::FromInternalValue(16)));
1012    EXPECT_CALL(*autofill_manager_->metric_logger(),
1013                LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0);
1014    EXPECT_CALL(*autofill_manager_->metric_logger(),
1015                LogFormFillDurationFromInteractionWithAutofill(
1016                    TimeDelta::FromInternalValue(12)));
1017    EXPECT_CALL(*autofill_manager_->metric_logger(),
1018                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
1019    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
1020    autofill_manager_->OnDidFillAutofillFormData(
1021        TimeTicks::FromInternalValue(5));
1022    autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
1023    autofill_manager_->Reset();
1024    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
1025  }
1026
1027  // Expect metric to be logged if the user both manually filled some fields
1028  // and autofilled others.  Messages can arrive out of order, so make sure they
1029  // take precedence appropriately.
1030  {
1031    EXPECT_CALL(*autofill_manager_->metric_logger(),
1032                LogFormFillDurationFromLoadWithAutofill(
1033                    TimeDelta::FromInternalValue(16)));
1034    EXPECT_CALL(*autofill_manager_->metric_logger(),
1035                LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0);
1036    EXPECT_CALL(*autofill_manager_->metric_logger(),
1037                LogFormFillDurationFromInteractionWithAutofill(
1038                    TimeDelta::FromInternalValue(14)));
1039    EXPECT_CALL(*autofill_manager_->metric_logger(),
1040                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
1041    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
1042    autofill_manager_->OnDidFillAutofillFormData(
1043        TimeTicks::FromInternalValue(5));
1044    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
1045                                            TimeTicks::FromInternalValue(3));
1046    autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
1047    autofill_manager_->Reset();
1048    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
1049  }
1050
1051  // Make sure that loading another form doesn't affect metrics from the first
1052  // form.
1053  {
1054    EXPECT_CALL(*autofill_manager_->metric_logger(),
1055                LogFormFillDurationFromLoadWithAutofill(
1056                    TimeDelta::FromInternalValue(16)));
1057    EXPECT_CALL(*autofill_manager_->metric_logger(),
1058                LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0);
1059    EXPECT_CALL(*autofill_manager_->metric_logger(),
1060                LogFormFillDurationFromInteractionWithAutofill(
1061                    TimeDelta::FromInternalValue(14)));
1062    EXPECT_CALL(*autofill_manager_->metric_logger(),
1063                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
1064    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
1065    autofill_manager_->OnFormsSeen(second_forms,
1066                                   TimeTicks::FromInternalValue(3));
1067    autofill_manager_->OnDidFillAutofillFormData(
1068        TimeTicks::FromInternalValue(5));
1069    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
1070                                            TimeTicks::FromInternalValue(3));
1071    autofill_manager_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
1072    autofill_manager_->Reset();
1073    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
1074  }
1075
1076  // Make sure that submitting a form that was loaded later will report the
1077  // later loading time.
1078  {
1079    EXPECT_CALL(*autofill_manager_->metric_logger(),
1080                LogFormFillDurationFromLoadWithoutAutofill(
1081                    TimeDelta::FromInternalValue(12)));
1082    EXPECT_CALL(*autofill_manager_->metric_logger(),
1083                LogFormFillDurationFromLoadWithAutofill(_)).Times(0);
1084    EXPECT_CALL(*autofill_manager_->metric_logger(),
1085                LogFormFillDurationFromInteractionWithAutofill(_)).Times(0);
1086    EXPECT_CALL(*autofill_manager_->metric_logger(),
1087                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
1088    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
1089    autofill_manager_->OnFormsSeen(second_forms,
1090                                   TimeTicks::FromInternalValue(5));
1091    autofill_manager_->FormSubmitted(second_form,
1092                                     TimeTicks::FromInternalValue(17));
1093    autofill_manager_->Reset();
1094    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
1095  }
1096}
1097
1098}  // namespace autofill
1099