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