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

chrome/browser/autofill/autofill_manager.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 "chrome/browser/autofill/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 33 matching lines @@
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/form_data_predictions.h"
 #include "webkit/glue/form_field.h"
 
+using base::TimeTicks;
 using switches::kEnableAutofillFeedback;
 using webkit_glue::FormData;
 using webkit_glue::FormDataPredictions;
 using webkit_glue::FormField;
 
 namespace {
 
 // We only send a fraction of the forms to upload server.
 // The rate for positive/negative matches potentially could be different.
 const double kAutofillPositiveUploadRateDefaultValue = 0.20;
@@ skipping 231 matching lines @@
     IPC_MESSAGE_HANDLER(AutofillHostMsg_DidFillAutofillFormData,
                         OnDidFillAutofillFormData)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_DidShowAutofillSuggestions,
                         OnDidShowAutofillSuggestions)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void AutofillManager::OnFormSubmitted(const FormData& form) {
+void AutofillManager::OnFormSubmitted(const FormData& form,
+                                      int64 timestamp) {
   // Let AutoComplete know as well.
   tab_contents_wrapper_->autocomplete_history_manager()->OnFormSubmitted(form);
 
   if (!IsAutofillEnabled())
     return;
 
   if (tab_contents()->browser_context()->IsOffTheRecord())
     return;
 
   // Don't save data that was submitted through JavaScript.
@@ skipping 12 matching lines @@
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return;
   submitted_form.UpdateFromCache(*cached_submitted_form);
 
   // Only upload server statistics and UMA metrics if at least some local data
   // is available to use as a baseline.
   if (!personal_data_->profiles().empty() ||
       !personal_data_->credit_cards().empty()) {
     DeterminePossibleFieldTypesForUpload(&submitted_form);
-    submitted_form.LogQualityMetrics(*metric_logger_);
+    submitted_form.LogQualityMetrics(*metric_logger_,
+                                     initial_interaction_timestamp_,
+                                     TimeTicks::FromInternalValue(timestamp));
 
     if (submitted_form.ShouldBeCrowdsourced())
       UploadFormData(submitted_form);
   }
 
   if (!submitted_form.IsAutofillable(true))
     return;
 
   ImportFormData(submitted_form);
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms) {
   bool enabled = IsAutofillEnabled();
   if (!has_logged_autofill_enabled_) {
     metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
 
   if (!enabled)
     return;
 
   ParseForms(forms);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
-                                           const FormField& field) {
+                                           const FormField& field,
+                                           uint64 timestamp) {
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!FindCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   if (!user_did_type_) {
     user_did_type_ = true;
     metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
   }
 
   if (autofill_field->is_autofilled) {
     autofill_field->is_autofilled = false;
     metric_logger_->LogUserHappinessMetric(
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
 
     if (!user_did_edit_autofilled_field_) {
       user_did_edit_autofilled_field_ = true;
       metric_logger_->LogUserHappinessMetric(
           AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE);
     }
   }
+
+  // Messages might arrive out of order, so always remember the earliest
+  // timestamp.
+  base::TimeTicks interaction_time = TimeTicks::FromInternalValue(timestamp);
+  if (initial_interaction_timestamp_.is_null() ||
+      interaction_time < initial_interaction_timestamp_) {
+    initial_interaction_timestamp_ = interaction_time;
+  }
 }
 
 void AutofillManager::OnQueryFormFieldAutofill(
     int query_id,
     const webkit_glue::FormData& form,
     const webkit_glue::FormField& field) {
   std::vector<string16> values;
   std::vector<string16> labels;
   std::vector<string16> icons;
   std::vector<int> unique_ids;
@@ skipping 229 matching lines @@
 }
 
 void AutofillManager::OnDidPreviewAutofillFormData() {
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_AUTOFILL_DID_FILL_FORM_DATA,
       Source<RenderViewHost>(tab_contents()->render_view_host()),
       NotificationService::NoDetails());
 }
 
 
-void AutofillManager::OnDidFillAutofillFormData() {
+void AutofillManager::OnDidFillAutofillFormData(uint64 timestamp) {
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_AUTOFILL_DID_FILL_FORM_DATA,
       Source<RenderViewHost>(tab_contents()->render_view_host()),
       NotificationService::NoDetails());
 
   metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_AUTOFILL);
   if (!user_did_autofill_) {
     user_did_autofill_ = true;
     metric_logger_->LogUserHappinessMetric(
         AutofillMetrics::USER_DID_AUTOFILL_ONCE);
   }
+
+  // Messages might arrive out of order, so always remember the earliest
+  // timestamp.
+  base::TimeTicks interaction_time = TimeTicks::FromInternalValue(timestamp);
+  if (initial_interaction_timestamp_.is_null() ||
+      interaction_time < initial_interaction_timestamp_) {
+    initial_interaction_timestamp_ = interaction_time;
+  }
 }
 
 void AutofillManager::OnDidShowAutofillSuggestions(bool is_new_popup) {
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_AUTOFILL_DID_SHOW_SUGGESTIONS,
       Source<RenderViewHost>(tab_contents()->render_view_host()),
       NotificationService::NoDetails());
 
   if (is_new_popup) {
     metric_logger_->LogUserHappinessMetric(AutofillMetrics::SUGGESTIONS_SHOWN);
@@ skipping 110 matching lines @@
 }
 
 void AutofillManager::Reset() {
   form_structures_.reset();
   has_logged_autofill_enabled_ = false;
   has_logged_address_suggestions_count_ = false;
   did_show_suggestions_ = false;
   user_did_type_ = false;
   user_did_autofill_ = false;
   user_did_edit_autofilled_field_ = false;
+  initial_interaction_timestamp_ = TimeTicks::FromInternalValue(0);

[jar (doing other things), 2011/08/31 17:02:21]

This seems strange that you are supplying a specific "internal value" of 0, and
seemingly violating the privacy of that class.  IMO, you really intend to
provide a TimeTicks values that is_null(), and so you should call:
TimeTicks::TimeTicks().

[Ilya Sherman, 2011/08/31 21:56:23]

Done.

 }
 
 AutofillManager::AutofillManager(TabContentsWrapper* tab_contents,
                                  PersonalDataManager* personal_data)
     : TabContentsObserver(tab_contents->tab_contents()),
       tab_contents_wrapper_(tab_contents),
       personal_data_(personal_data),
       download_manager_(NULL),
       disable_download_manager_requests_(true),
       metric_logger_(new AutofillMetrics),
@@ skipping 356 matching lines @@
 void AutofillManager::UnpackGUIDs(int id,
                                   GUIDPair* cc_guid,
                                   GUIDPair* profile_guid) {
   int cc_id = id >> std::numeric_limits<unsigned short>::digits &
       std::numeric_limits<unsigned short>::max();
   int profile_id = id & std::numeric_limits<unsigned short>::max();
 
   *cc_guid = IDToGUID(cc_id);
   *profile_guid = IDToGUID(profile_id);
 }