Add metrics to measure time elapsed between form load and form submission with or without Autofill.

chrome/browser/autofill/autofill_metrics_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_common_test.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #include "chrome/browser/autofill/autofill_metrics.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/browser/ui/tab_contents/test_tab_contents_wrapper.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_field.h"
 
+using ::testing::_;
+using ::testing::AnyNumber;
+using ::testing::Mock;
+using base::TimeTicks;
+using base::TimeDelta;
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 
 namespace {
 
 class MockAutofillMetrics : public AutofillMetrics {
  public:
   MockAutofillMetrics() {}
   MOCK_CONST_METHOD1(LogCreditCardInfoBarMetric, void(InfoBarMetric metric));
   MOCK_CONST_METHOD3(LogHeuristicTypePrediction,
                      void(FieldTypeQualityMetric metric,
                           AutofillFieldType field_type,
                           const std::string& experiment_id));
   MOCK_CONST_METHOD3(LogOverallTypePrediction,
                      void(FieldTypeQualityMetric metric,
                           AutofillFieldType field_type,
                           const std::string& experiment_id));
   MOCK_CONST_METHOD3(LogServerTypePrediction,
                      void(FieldTypeQualityMetric metric,
                           AutofillFieldType field_type,
                           const std::string& experiment_id));
   MOCK_CONST_METHOD2(LogQualityMetric, void(QualityMetric metric,
                                             const std::string& experiment_id));
   MOCK_CONST_METHOD1(LogServerQueryMetric, void(ServerQueryMetric metric));
   MOCK_CONST_METHOD1(LogUserHappinessMetric, void(UserHappinessMetric metric));
+  MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithAutofill,
+                     void(const TimeDelta& duration));
+  MOCK_CONST_METHOD1(LogFormFillDurationFromLoadWithoutAutofill,
+                     void(const TimeDelta& duration));
+  MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithAutofill,
+                     void(const TimeDelta& duration));
+  MOCK_CONST_METHOD1(LogFormFillDurationFromInteractionWithoutAutofill,
+                     void(const TimeDelta& duration));
   MOCK_CONST_METHOD1(LogIsAutofillEnabledAtPageLoad, void(bool enabled));
   MOCK_CONST_METHOD1(LogIsAutofillEnabledAtStartup, void(bool enabled));
   MOCK_CONST_METHOD1(LogStoredProfileCount, void(size_t num_profiles));
   MOCK_CONST_METHOD1(LogAddressSuggestionsCount, void(size_t num_suggestions));
   MOCK_CONST_METHOD1(LogServerExperimentIdForQuery,
                      void(const std::string& experiment_id));
   MOCK_CONST_METHOD1(LogServerExperimentIdForUpload,
                      void(const std::string& experiment_id));
 
  private:
@@ skipping 102 matching lines @@
     set_metric_logger(new MockAutofillMetrics);
   }
   virtual ~TestAutofillManager() {}
 
   virtual bool IsAutofillEnabled() const { return autofill_enabled_; }
 
   void set_autofill_enabled(bool autofill_enabled) {
     autofill_enabled_ = autofill_enabled;
   }
 
-  const MockAutofillMetrics* metric_logger() const {
-    return static_cast<const MockAutofillMetrics*>(
-        AutofillManager::metric_logger());
+  MockAutofillMetrics* metric_logger() {
+    return static_cast<MockAutofillMetrics*>(const_cast<AutofillMetrics*>(
+        AutofillManager::metric_logger()));
   }
 
   void AddSeenForm(const FormData& form,
                    const std::vector<AutofillFieldType>& heuristic_types,
                    const std::vector<AutofillFieldType>& server_types,
                    const std::string& experiment_id) {
     FormData empty_form = form;
     for (size_t i = 0; i < empty_form.fields.size(); ++i) {
       empty_form.fields[i].value = string16();
     }
@@ skipping 203 matching lines @@
               LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
                   PHONE_HOME_WHOLE_NUMBER, std::string()));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED,
                                std::string()));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogUserHappinessMetric(
                   AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME));
 
   // Simulate form submission.
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 }
 
 // Test that we log the appropriate additional metrics when Autofill failed.
 TEST_F(AutofillMetricsTest, QualityMetricsForFailure) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
@@ skipping 96 matching lines @@
                                  std::string()));
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogQualityMetric(failure_cases[i].heuristic_metric,
                                  std::string()));
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogQualityMetric(failure_cases[i].server_metric,
                                  std::string()));
   }
 
   // Simulate form submission.
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 }
 
 // Test that we behave sanely when the cached form differs from the submitted
 // one.
 TEST_F(AutofillMetricsTest, SaneMetricsWithCacheMismatch) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://example.com/form.html");
@@ skipping 136 matching lines @@
               LogServerTypePrediction(AutofillMetrics::TYPE_MATCH,
                   NAME_FULL, std::string()));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogOverallTypePrediction(AutofillMetrics::TYPE_MATCH,
                   NAME_FULL, std::string()));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogQualityMetric(AutofillMetrics::FIELD_AUTOFILLED,
                                std::string()));
 
   // Simulate form submission.
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 }
 
 // Test that we don't log quality metrics for non-autofillable forms.
 TEST_F(AutofillMetricsTest, NoQualityMetricsForNonAutofillableForms) {
   // Forms must include at least three fields to be auto-fillable.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
   form.user_submitted = true;
 
   FormField field;
   autofill_test::CreateTestFormField(
       "Autofilled", "autofilled", "Elvis Presley", "text", &field);
   field.is_autofilled = true;
   form.fields.push_back(field);
   autofill_test::CreateTestFormField(
       "Autofill Failed", "autofillfailed", "buddy@gmail.com", "text", &field);
   form.fields.push_back(field);
 
   // Simulate form submission.
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED,
                                std::string())).Times(0);
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 
   // Search forms are not auto-fillable.
   form.action = GURL("http://example.com/search?q=Elvis%20Presley");
   autofill_test::CreateTestFormField(
       "Empty", "empty", "", "text", &field);
   form.fields.push_back(field);
 
   // Simulate form submission.
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogQualityMetric(AutofillMetrics::FIELD_SUBMITTED,
                                std::string())).Times(0);
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 }
 
 // Test that we recored the experiment id appropriately.
 TEST_F(AutofillMetricsTest, QualityMetricsWithExperimentId) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
@@ skipping 104 matching lines @@
               LogHeuristicTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
                                          ADDRESS_HOME_COUNTRY, experiment_id));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogServerTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
                                       ADDRESS_HOME_COUNTRY, experiment_id));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogOverallTypePrediction(AutofillMetrics::TYPE_UNKNOWN,
                                        ADDRESS_HOME_COUNTRY, experiment_id));
 
   // Simulate form submission.
-  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form));
+  EXPECT_NO_FATAL_FAILURE(autofill_manager_->OnFormSubmitted(form,
+                                                             TimeTicks::Now()));
 }
 
 // Test that the profile count is logged correctly.
 TEST_F(AutofillMetricsTest, StoredProfileCount) {
   // The metric should be logged when the profiles are first loaded.
   EXPECT_CALL(*test_personal_data_->metric_logger(),
               LogStoredProfileCount(2)).Times(1);
   test_personal_data_->LoadProfiles();
 
   // The metric should only be logged once.
@@ skipping 84 matching lines @@
 
 // Test that we log whether Autofill is enabled when filling a form.
 TEST_F(AutofillMetricsTest, AutofillIsEnabledAtPageLoad) {
   // Establish our expectations.
   ::testing::FLAGS_gmock_verbose = "error";
   ::testing::InSequence dummy;
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogIsAutofillEnabledAtPageLoad(true)).Times(1);
 
   autofill_manager_->set_autofill_enabled(true);
-  autofill_manager_->OnFormsSeen(std::vector<FormData>());
+  autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks());
 
   // Reset the autofill manager state.
   autofill_manager_->Reset();
 
   // Establish our expectations.
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogIsAutofillEnabledAtPageLoad(false)).Times(1);
 
   autofill_manager_->set_autofill_enabled(false);
-  autofill_manager_->OnFormsSeen(std::vector<FormData>());
+  autofill_manager_->OnFormsSeen(std::vector<FormData>(), TimeTicks());
 }
 
 // Test that credit card infobar metrics are logged correctly.
 TEST_F(AutofillMetricsTest, CreditCardInfoBar) {
   MockAutofillMetrics metric_logger;
   ::testing::InSequence dummy;
 
   // Accept the infobar.
   {
     CreditCard* credit_card;
@@ skipping 86 matching lines @@
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Email", "email", "", "text", &field);
   form.fields.push_back(field);
 
   std::vector<FormData> forms(1, form);
 
   // Expect no notifications when the form is first seen.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED)).Times(0);
-    autofill_manager_->OnFormsSeen(forms);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks());
   }
 
 
   // Expect no notifications when the form is submitted.
   {
     EXPECT_CALL(
         *autofill_manager_->metric_logger(),
         LogUserHappinessMetric(
             AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL)).Times(0);
     EXPECT_CALL(
         *autofill_manager_->metric_logger(),
         LogUserHappinessMetric(
             AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME)).Times(0);
     EXPECT_CALL(
         *autofill_manager_->metric_logger(),
         LogUserHappinessMetric(
             AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE)).Times(0);
     EXPECT_CALL(
         *autofill_manager_->metric_logger(),
         LogUserHappinessMetric(
             AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM)).Times(0);
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
   // Add more fields to the form.
   autofill_test::CreateTestFormField("Phone", "phone", "", "text", &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Unknown", "unknown", "", "text", &field);
   form.fields.push_back(field);
   forms.front() = form;
 
   // Expect a notification when the form is first seen.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED));
-    autofill_manager_->OnFormsSeen(forms);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks());
   }
 
   // Expect a notification when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
   // Fill in two of the fields.
   form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
   form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
   forms.front() = form;
 
   // Expect a notification when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
   // Fill in the third field.
   form.fields[2].value = ASCIIToUTF16("12345678901");
   forms.front() = form;
 
   // Expect notifications when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_NONE));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
 
   // Mark one of the fields as autofilled.
   form.fields[1].is_autofilled = true;
   forms.front() = form;
 
   // Expect notifications when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
   // Mark all of the fillable fields as autofilled.
   form.fields[0].is_autofilled = true;
   form.fields[2].is_autofilled = true;
   forms.front() = form;
 
   // Expect notifications when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 
   // Clear out the third field's value.
   form.fields[2].value = string16();
   forms.front() = form;
 
   // Expect notifications when the form is submitted.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM));
-    autofill_manager_->OnFormSubmitted(form);
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::Now());
   }
 }
 
 // Verify that we correctly log user happiness metrics dealing with form
 // interaction.
 TEST_F(AutofillMetricsTest, UserHappinessFormInteraction) {
   // Load a fillable form.
   FormData form;
   form.name = ASCIIToUTF16("TestForm");
   form.method = ASCIIToUTF16("POST");
   form.origin = GURL("http://example.com/form.html");
   form.action = GURL("http://example.com/submit.html");
   form.user_submitted = true;
 
   FormField field;
   autofill_test::CreateTestFormField("Name", "name", "", "text", &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Email", "email", "", "text", &field);
   form.fields.push_back(field);
   autofill_test::CreateTestFormField("Phone", "phone", "", "text", &field);
   form.fields.push_back(field);
 
   std::vector<FormData> forms(1, form);
 
   // Expect a notification when the form is first seen.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED));
-    autofill_manager_->OnFormsSeen(forms);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks());
   }
 
   // Simulate typing.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE));
-    autofill_manager_->OnTextFieldDidChange(form, form.fields.front());
+    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                            TimeTicks());
   }
 
   // Simulate suggestions shown twice for a single edit (i.e. multiple
   // keystrokes in a single field).
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::SUGGESTIONS_SHOWN)).Times(1);
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
@@ skipping 12 matching lines @@
     autofill_manager_->OnDidShowAutofillSuggestions(true);
   }
 
   // Simulate invoking autofill.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL));
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::USER_DID_AUTOFILL_ONCE));
-    autofill_manager_->OnDidFillAutofillFormData();
+    autofill_manager_->OnDidFillAutofillFormData(TimeTicks());
   }
 
   // Simulate editing an autofilled field.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD));
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE));
     AutofillManager::GUIDPair guid("00000000-0000-0000-0000-000000000001", 0);
     AutofillManager::GUIDPair empty(std::string(), 0);
     autofill_manager_->OnFillAutofillFormData(
         0, form, form.fields.front(),
         autofill_manager_->PackGUIDs(empty, guid));
-    autofill_manager_->OnTextFieldDidChange(form, form.fields.front());
+    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                            TimeTicks());
     // Simulate a second keystroke; make sure we don't log the metric twice.
-    autofill_manager_->OnTextFieldDidChange(form, form.fields.front());
+    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                            TimeTicks());
   }
 
   // Simulate invoking autofill again.
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL));
   EXPECT_CALL(*autofill_manager_->metric_logger(),
               LogUserHappinessMetric(
                   AutofillMetrics::USER_DID_AUTOFILL_ONCE)).Times(0);
-  autofill_manager_->OnDidFillAutofillFormData();
+  autofill_manager_->OnDidFillAutofillFormData(TimeTicks());
 
   // Simulate editing another autofilled field.
   {
     EXPECT_CALL(*autofill_manager_->metric_logger(),
                 LogUserHappinessMetric(
                     AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD));
-    autofill_manager_->OnTextFieldDidChange(form, form.fields[1]);
+    autofill_manager_->OnTextFieldDidChange(form, form.fields[1], TimeTicks());
   }
 }
+
+// Verify that we correctly log metrics tracking the duration of form fill.
+TEST_F(AutofillMetricsTest, FormFillDuration) {
+  // Load a fillable form.
+  FormData form;
+  form.name = ASCIIToUTF16("TestForm");
+  form.method = ASCIIToUTF16("POST");
+  form.origin = GURL("http://example.com/form.html");
+  form.action = GURL("http://example.com/submit.html");
+  form.user_submitted = true;
+
+  FormField field;
+  autofill_test::CreateTestFormField("Name", "name", "", "text", &field);
+  form.fields.push_back(field);
+  autofill_test::CreateTestFormField("Email", "email", "", "text", &field);
+  form.fields.push_back(field);
+  autofill_test::CreateTestFormField("Phone", "phone", "", "text", &field);
+  form.fields.push_back(field);
+
+  std::vector<FormData> forms(1, form);
+
+  // Fill the field values for form submission.
+  form.fields[0].value = ASCIIToUTF16("Elvis Aaron Presley");
+  form.fields[1].value = ASCIIToUTF16("theking@gmail.com");
+  form.fields[2].value = ASCIIToUTF16("12345678901");
+
+  // Ignore any non-timing metrics.
+  // CAUTION: This is a global variable.  So as to not affect other tests, this
+  // _must_ be restored to "warning" at the end of the test.
+  ::testing::FLAGS_gmock_verbose = "error";
+
+  // Expect only form load metrics to be logged if the form is submitted without
+  // user interaction.
+  {
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithoutAutofill(
+                    TimeDelta::FromInternalValue(16)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::FromInternalValue(17));
+    autofill_manager_->Reset();
+    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
+  }
+
+  // Expect metric to be logged if the user manually edited a form field.
+  {
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithoutAutofill(
+                    TimeDelta::FromInternalValue(16)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithoutAutofill(
+                    TimeDelta::FromInternalValue(14)));
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
+    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                            TimeTicks::FromInternalValue(3));
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::FromInternalValue(17));
+    autofill_manager_->Reset();
+    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
+  }
+
+  // Expect metric to be logged if the user autofilled the form.
+  form.fields[0].is_autofilled = true;
+  {
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithAutofill(
+                    TimeDelta::FromInternalValue(16)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithAutofill(
+                    TimeDelta::FromInternalValue(12)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
+    autofill_manager_->OnDidFillAutofillFormData(
+        TimeTicks::FromInternalValue(5));
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::FromInternalValue(17));
+    autofill_manager_->Reset();
+    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
+  }
+
+  // Expect metric to be logged if the user both manually filled some fields
+  // and autofilled others.  Messages can arrive out of order, so make sure they
+  // take precedence appropriately.
+  {
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithAutofill(
+                    TimeDelta::FromInternalValue(16)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromLoadWithoutAutofill(_)).Times(0);
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithAutofill(
+                    TimeDelta::FromInternalValue(14)));
+    EXPECT_CALL(*autofill_manager_->metric_logger(),
+                LogFormFillDurationFromInteractionWithoutAutofill(_)).Times(0);
+    autofill_manager_->OnFormsSeen(forms, TimeTicks::FromInternalValue(1));
+    autofill_manager_->OnDidFillAutofillFormData(
+        TimeTicks::FromInternalValue(5));
+    autofill_manager_->OnTextFieldDidChange(form, form.fields.front(),
+                                            TimeTicks::FromInternalValue(3));
+    autofill_manager_->OnFormSubmitted(form, TimeTicks::FromInternalValue(17));
+    autofill_manager_->Reset();
+    Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
+  }
+
+  // Restore the global Gmock verbosity level to its default value.
+  ::testing::FLAGS_gmock_verbose = "warning";
+}