[Autofill] Add UMA timing metrics for requestAutocomplete dialog.

chrome/browser/autofill/autofill_metrics_unittest.cc

 // Copyright (c) 2012 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/bind.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/autocheckout_infobar_delegate.h"
 #include "chrome/browser/autofill/autocheckout_page_meta_data.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_manager_delegate.h"
 #include "chrome/browser/autofill/autofill_metrics.h"
 #include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
+#include "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 #include "chrome/browser/ui/autofill/tab_autofill_manager_delegate.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/form_data.h"
 #include "chrome/common/form_field_data.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 
 using content::BrowserThread;
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Mock;
 using base::TimeTicks;
 using base::TimeDelta;
 
 namespace {
 
 class MockAutofillMetrics : public AutofillMetrics {
  public:
   MockAutofillMetrics() {}
   MOCK_CONST_METHOD1(LogCreditCardInfoBarMetric, void(InfoBarMetric metric));
   MOCK_CONST_METHOD1(LogAutocheckoutInfoBarMetric, void(InfoBarMetric metric));
+  MOCK_CONST_METHOD3(LogRequestAutocompleteUiDuration,
+                     void(const TimeDelta& duration,
+                          autofill::DialogRequester requester,
+                          DialogDismissalAction dismissal_action));
   MOCK_CONST_METHOD1(LogDeveloperEngagementMetric,
                      void(DeveloperEngagementMetric 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));
@@ skipping 26 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockAutofillMetrics);
 };
 
 class TestPersonalDataManager : public PersonalDataManager {
  public:
   TestPersonalDataManager() : autofill_enabled_(true) {
     set_metric_logger(new MockAutofillMetrics);
     CreateTestAutofillProfiles(&web_profiles_);
   }
 
+  static ProfileKeyedService* Build(Profile* profile) {
+    return new TestPersonalDataManager();
+  }
+
   void SetBrowserContext(content::BrowserContext* context) {
     set_browser_context(context);
   }
 
   // Overridden to avoid a trip to the database. This should be a no-op except
   // for the side-effect of logging the profile count.
   virtual void LoadProfiles() OVERRIDE {
     std::vector<AutofillProfile*> profiles;
     web_profiles_.release(&profiles);
     WDResult<std::vector<AutofillProfile*> > result(AUTOFILL_PROFILES_RESULT,
@@ skipping 152 matching lines @@
   // AutofillManager is ref counted.
   virtual ~TestAutofillManager() {}
 
   bool autofill_enabled_;
   bool did_finish_async_form_submit_;
   bool message_loop_is_running_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAutofillManager);
 };
 
-class TestAutocheckoutManager : public AutocheckoutManager {
+class TestAutocheckoutManager : public autofill::AutocheckoutManager {
  public:
   explicit TestAutocheckoutManager(AutofillManager* autofill_manager)
       : AutocheckoutManager(autofill_manager) {
   }
 
   virtual void ShowAutocheckoutDialog(
       const GURL& frame_url,
       const content::SSLStatus& ssl_status) OVERRIDE {
     // no-op. Just used as callback from autocheckout_infobar_delegate.
   }
 
   virtual ~TestAutocheckoutManager() {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestAutocheckoutManager);
 };
 
+void MockRequestAutocompleteDialogCallback(const FormStructure*) {
+}
+
 }  // namespace
 
 class AutofillMetricsTest : public ChromeRenderViewHostTestHarness {
  public:
   AutofillMetricsTest();
   virtual ~AutofillMetricsTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
  protected:
   scoped_ptr<ConfirmInfoBarDelegate> CreateDelegate(
       MockAutofillMetrics* metric_logger,
       CreditCard** created_card);
 
   scoped_ptr<ConfirmInfoBarDelegate> CreateAutocheckoutDelegate(
       MockAutofillMetrics* metric_logger);
 
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
+  content::TestBrowserThread io_thread_;
 
   scoped_refptr<TestAutofillManager> autofill_manager_;
   TestAutocheckoutManager autocheckout_manager_;
-  TestPersonalDataManager personal_data_;
+  TestPersonalDataManager* personal_data_;
 
  private:
   std::string default_gmock_verbosity_level_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillMetricsTest);
 };
 
 AutofillMetricsTest::AutofillMetricsTest()
   : ChromeRenderViewHostTestHarness(),
     ui_thread_(BrowserThread::UI, &message_loop_),
     file_thread_(BrowserThread::FILE),
+    io_thread_(BrowserThread::IO),
     autocheckout_manager_(NULL) {
 }
 
 AutofillMetricsTest::~AutofillMetricsTest() {
   // Order of destruction is important as AutofillManager relies on
   // PersonalDataManager to be around when it gets destroyed.
   autofill_manager_ = NULL;
 }
 
 void AutofillMetricsTest::SetUp() {
-  Profile* profile = new TestingProfile();
+  TestingProfile* profile = new TestingProfile();
+  profile->CreateRequestContext();
   browser_context_.reset(profile);
-  PersonalDataManagerFactory::GetInstance()->SetTestingFactory(profile, NULL);
+  personal_data_ =
+      static_cast<TestPersonalDataManager*>(
+          PersonalDataManagerFactory::GetInstance()->SetTestingFactoryAndUse(
+              profile, TestPersonalDataManager::Build));
 
   ChromeRenderViewHostTestHarness::SetUp();
-  TabAutofillManagerDelegate::CreateForWebContents(web_contents());
-  personal_data_.SetBrowserContext(profile);
+  io_thread_.StartIOThread();
+
+  autofill::TabAutofillManagerDelegate::CreateForWebContents(web_contents());
+  personal_data_->SetBrowserContext(profile);
   autofill_manager_ = new TestAutofillManager(
       web_contents(),
-      TabAutofillManagerDelegate::FromWebContents(web_contents()),
-      &personal_data_);
+      autofill::TabAutofillManagerDelegate::FromWebContents(web_contents()),
+      personal_data_);
 
   file_thread_.Start();
 
   // Ignore any metrics that we haven't explicitly set expectations for.
   // If we don't override the verbosity level, we'll get lots of log spew from
   // mocked functions that aren't relevant to a test but happen to be called
   // during the test's execution.
   // CAUTION: This is a global variable.  So as to not affect other tests, this
   // _must_ be restored to its original value at the end of the test.
   default_gmock_verbosity_level_ = ::testing::FLAGS_gmock_verbose;
   ::testing::FLAGS_gmock_verbose = "error";
 }
 
 void AutofillMetricsTest::TearDown() {
   // Restore the global Gmock verbosity level to its default value.
   ::testing::FLAGS_gmock_verbose = default_gmock_verbosity_level_;
 
   // Order of destruction is important as AutofillManager relies on
   // PersonalDataManager to be around when it gets destroyed. Also, a real
   // AutofillManager is tied to the lifetime of the WebContents, so it must
   // be destroyed at the destruction of the WebContents.
   autofill_manager_ = NULL;
   file_thread_.Stop();
+
+  profile()->ResetRequestContext();
   ChromeRenderViewHostTestHarness::TearDown();
+  io_thread_.Stop();
 }
 
 scoped_ptr<ConfirmInfoBarDelegate> AutofillMetricsTest::CreateDelegate(
     MockAutofillMetrics* metric_logger,
     CreditCard** created_card) {
   EXPECT_CALL(*metric_logger,
               LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_SHOWN));
   // The delegate created below will take ownership of this object.
   CreditCard* credit_card = new CreditCard();
   if (created_card)
     *created_card = credit_card;
-  return AutofillCCInfoBarDelegate::Create(credit_card, &personal_data_,
+  return AutofillCCInfoBarDelegate::Create(credit_card, personal_data_,
                                            metric_logger);
 }
 
 scoped_ptr<ConfirmInfoBarDelegate>
 AutofillMetricsTest::CreateAutocheckoutDelegate(
     MockAutofillMetrics* metric_logger) {
   EXPECT_CALL(*metric_logger,
               LogAutocheckoutInfoBarMetric(AutofillMetrics::INFOBAR_SHOWN));
   GURL url("www.google.com");
   content::SSLStatus ssl_status;
-  return AutocheckoutInfoBarDelegate::Create(
+  return autofill::AutocheckoutInfoBarDelegate::Create(
       *metric_logger,
       url,
       ssl_status,
       &autocheckout_manager_);
 }
 
 // Test that we log quality metrics appropriately.
 TEST_F(AutofillMetricsTest, QualityMetrics) {
   // Set up our form data.
   FormData form;
@@ skipping 657 matching lines @@
                                        ADDRESS_HOME_COUNTRY, experiment_id));
 
   // Simulate form submission.
   EXPECT_NO_FATAL_FAILURE(autofill_manager_->FormSubmitted(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(*personal_data_.metric_logger(),
+  EXPECT_CALL(*personal_data_->metric_logger(),
               LogStoredProfileCount(2)).Times(1);
-  personal_data_.LoadProfiles();
+  personal_data_->LoadProfiles();
 
   // The metric should only be logged once.
-  EXPECT_CALL(*personal_data_.metric_logger(),
+  EXPECT_CALL(*personal_data_->metric_logger(),
               LogStoredProfileCount(::testing::_)).Times(0);
-  personal_data_.LoadProfiles();
+  personal_data_->LoadProfiles();
 }
 
 // Test that we correctly log whether Autofill is enabled.
 TEST_F(AutofillMetricsTest, AutofillIsEnabledAtStartup) {
-  personal_data_.set_autofill_enabled(true);
-  EXPECT_CALL(*personal_data_.metric_logger(),
+  personal_data_->set_autofill_enabled(true);
+  EXPECT_CALL(*personal_data_->metric_logger(),
               LogIsAutofillEnabledAtStartup(true)).Times(1);
-  personal_data_.Init(profile());
-  personal_data_.Shutdown();
+  personal_data_->Init(profile());
+  personal_data_->Shutdown();
 
-  personal_data_.set_autofill_enabled(false);
-  EXPECT_CALL(*personal_data_.metric_logger(),
+  personal_data_->set_autofill_enabled(false);
+  EXPECT_CALL(*personal_data_->metric_logger(),
               LogIsAutofillEnabledAtStartup(false)).Times(1);
-  personal_data_.Init(profile());
+  personal_data_->Init(profile());
 }
 
 // Test that we log the number of Autofill suggestions when filling a form.
 TEST_F(AutofillMetricsTest, AddressSuggestionsCount) {
   // 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 84 matching lines @@
 TEST_F(AutofillMetricsTest, CreditCardInfoBar) {
   MockAutofillMetrics metric_logger;
   ::testing::InSequence dummy;
 
   // Accept the infobar.
   {
     CreditCard* credit_card;
     scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger,
                                                               &credit_card));
     ASSERT_TRUE(infobar);
-    EXPECT_CALL(personal_data_, SaveImportedCreditCard(*credit_card));
+    EXPECT_CALL(*personal_data_, SaveImportedCreditCard(*credit_card));
     EXPECT_CALL(metric_logger,
         LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_ACCEPTED)).Times(1);
     EXPECT_CALL(metric_logger,
         LogCreditCardInfoBarMetric(AutofillMetrics::INFOBAR_IGNORED)).Times(0);
     EXPECT_TRUE(infobar->Accept());
   }
 
   // Cancel the infobar.
   {
     scoped_ptr<ConfirmInfoBarDelegate> infobar(CreateDelegate(&metric_logger,
@@ skipping 79 matching lines @@
   {
     scoped_ptr<ConfirmInfoBarDelegate> infobar(
         CreateAutocheckoutDelegate(&metric_logger));
     ASSERT_TRUE(infobar);
     EXPECT_CALL(metric_logger,
         LogAutocheckoutInfoBarMetric(
             AutofillMetrics::INFOBAR_IGNORED)).Times(1);
   }
 }
 
+// TODO(isherman): Enable this test on other platforms once the UI is
+// implemented on those platforms.
+#if defined(TOOLKIT_VIEWS)
+TEST_F(AutofillMetricsTest, RequestAutocompleteUiDuration) {
+  MockAutofillMetrics metric_logger;
+  ::testing::InSequence dummy;
+
+  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;
+
+  FormFieldData field;
+  field.autocomplete_attribute = "email";
+  form.fields.push_back(field);
+
+  // Submit the form data.
+  {
+    EXPECT_CALL(metric_logger,
+                LogRequestAutocompleteUiDuration(
+                    _,
+                    autofill::DIALOG_REQUESTER_REQUEST_AUTOCOMPLETE,
+                    AutofillMetrics::DIALOG_ACCEPTED)).Times(1);
+
+    autofill::AutofillDialogControllerImpl* dialog_controller =
+        new autofill::AutofillDialogControllerImpl(
+            web_contents(), form, GURL(), content::SSLStatus(),
+            metric_logger,
+            autofill::DIALOG_REQUESTER_REQUEST_AUTOCOMPLETE,
+            base::Bind(&MockRequestAutocompleteDialogCallback));
+    dialog_controller->Show();
+    dialog_controller->ViewClosed(autofill::ACTION_SUBMIT);
+  }
+
+  // Cancel out of the dialog.
+  {
+    EXPECT_CALL(metric_logger,
+                LogRequestAutocompleteUiDuration(
+                    _, autofill::DIALOG_REQUESTER_AUTOCHECKOUT,
+                    AutofillMetrics::DIALOG_CANCELED)).Times(1);
+
+    autofill::AutofillDialogControllerImpl* dialog_controller =
+        new autofill::AutofillDialogControllerImpl(
+            web_contents(), form, GURL(), content::SSLStatus(),
+            metric_logger, autofill::DIALOG_REQUESTER_AUTOCHECKOUT,
+            base::Bind(&MockRequestAutocompleteDialogCallback));
+    dialog_controller->Show();
+    dialog_controller->ViewClosed(autofill::ACTION_ABORT);
+  }
+
+  // Take some other action that dismisses the dialog.
+  {
+    EXPECT_CALL(metric_logger,
+                LogRequestAutocompleteUiDuration(
+                    _,
+                    autofill::DIALOG_REQUESTER_AUTOCHECKOUT,
+                    AutofillMetrics::DIALOG_CANCELED)).Times(1);
+
+    autofill::AutofillDialogControllerImpl* dialog_controller =
+        new autofill::AutofillDialogControllerImpl(
+            web_contents(), form, GURL(), content::SSLStatus(),
+            metric_logger, autofill::DIALOG_REQUESTER_AUTOCHECKOUT,
+            base::Bind(&MockRequestAutocompleteDialogCallback));
+    dialog_controller->Show();
+    dialog_controller->Hide();
+  }
+}
+#endif  // defined(TOOLKIT_VIEWS)
 
 // Test that server query response experiment id metrics are logged correctly.
 TEST_F(AutofillMetricsTest, ServerQueryExperimentIdForQuery) {
   MockAutofillMetrics metric_logger;
   ::testing::InSequence dummy;
 
   // No experiment specified.
   EXPECT_CALL(metric_logger,
               LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_RECEIVED));
   EXPECT_CALL(metric_logger,
@@ skipping 369 matching lines @@
     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_->FormSubmitted(form, TimeTicks::FromInternalValue(17));
     autofill_manager_->Reset();
     Mock::VerifyAndClearExpectations(autofill_manager_->metric_logger());
   }
 }