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