Add metrics to track Autofill "user happiness"

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 209 matching lines @@
 }  // namespace
 
 AutofillManager::AutofillManager(TabContentsWrapper* tab_contents)
     : TabContentsObserver(tab_contents->tab_contents()),
       tab_contents_wrapper_(tab_contents),
       personal_data_(NULL),
       download_manager_(tab_contents->profile()),
       disable_download_manager_requests_(false),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
-      has_logged_address_suggestions_count_(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) {
   DCHECK(tab_contents);
 
   // |personal_data_| is NULL when using TestTabContents.
   personal_data_ =
       tab_contents->profile()->GetOriginalProfile()->GetPersonalDataManager();
   download_manager_.SetObserver(this);
 }
 
 AutofillManager::~AutofillManager() {
   download_manager_.SetObserver(NULL);
@@ skipping 30 matching lines @@
     const content::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   Reset();
 }
 
 bool AutofillManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AutofillManager, message)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_FormsSeen, OnFormsSeen)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_FormSubmitted, OnFormSubmitted)
+    IPC_MESSAGE_HANDLER(AutofillHostMsg_TextFieldDidChange,
+                        OnTextFieldDidChange)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_QueryFormFieldAutofill,
                         OnQueryFormFieldAutofill)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowAutofillDialog,
                         OnShowAutofillDialog)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_FillAutofillFormData,
                         OnFillAutofillFormData)
+    IPC_MESSAGE_HANDLER(AutofillHostMsg_DidPreviewAutofillFormData,
+                        OnDidPreviewAutofillFormData)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_DidFillAutofillFormData,
                         OnDidFillAutofillFormData)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_DidShowAutofillSuggestions,
                         OnDidShowAutofillSuggestions)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
@@ skipping 48 matching lines @@
     metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
 
   if (!enabled)
     return;
 
   ParseForms(forms);
 }
 
+void AutofillManager::OnTextFieldDidChange(const FormData& form,
+                                           const FormField& field) {
+  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);
+    }
+  }
+}
+
 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;
 
   RenderViewHost* host = NULL;
@@ skipping 136 matching lines @@
         if (profile) {
           DCHECK_NE(AutofillType::CREDIT_CARD,
                     AutofillType(field_type).group());
           FillFormField(*profile, *autofill_field, profile_guid.second,
                         &(*iter));
         } else {
           DCHECK_EQ(AutofillType::CREDIT_CARD,
                     AutofillType(field_type).group());
           FillCreditCardFormField(*credit_card, field_type, &(*iter));
         }
+
+        // Mark the cached field as autofilled, so that we can detect when a
+        // user edits an autofilled field (for metrics).
+        autofill_field->is_autofilled = true;
         break;
       }
     }
 
     host->Send(new AutofillMsg_FormDataFilled(host->routing_id(), query_id,
                                               result));
     return;
   }
 
   // The list of fields in |form_structure| and |result.fields| often match
@@ skipping 31 matching lines @@
         if (result.fields[j] == field) {
           FillFormField(*profile, *cached_field, profile_guid.second,
                         &result.fields[j]);
         } else {
           FillFormField(*profile, *cached_field, 0, &result.fields[j]);
         }
       } else {
         DCHECK_EQ(AutofillType::CREDIT_CARD, field_group_type);
         FillCreditCardFormField(*credit_card, field_type, &result.fields[j]);
       }
+
+      // Mark the cached field as autofilled, so that we can detect when a user
+      // edits an autofilled field (for metrics).
+      form_structure->field(k)->is_autofilled = true;
     }
 
     // We found a matching field in the |form_structure|, so on the next
     // iteration we should proceed to the next |form_structure| field.
     ++i;
   }
 
   autofilled_form_signatures_.push_front(form_structure->FormSignature());
   // Only remember the last few forms that we've seen, both to avoid false
   // positives and to avoid wasting memory.
   if (autofilled_form_signatures_.size() > kMaxRecentFormSignaturesToRemember)
     autofilled_form_signatures_.pop_back();
 
   host->Send(new AutofillMsg_FormDataFilled(
       host->routing_id(), query_id, result));
 }
 
 void AutofillManager::OnShowAutofillDialog() {
   Browser* browser = BrowserList::GetLastActiveWithProfile(
       Profile::FromBrowserContext(tab_contents()->browser_context()));
   if (browser)
     browser->ShowOptionsTab(chrome::kAutofillSubPage);
 }
 
+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() {
   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);
+  }
 }
 
-void AutofillManager::OnDidShowAutofillSuggestions() {
+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);
+
+    if (!did_show_suggestions_) {
+      did_show_suggestions_ = true;
+      metric_logger_->LogUserHappinessMetric(
+          AutofillMetrics::SUGGESTIONS_SHOWN_ONCE);
+    }
+  }
 }
 
 void AutofillManager::OnLoadedServerPredictions(
     const std::string& response_xml) {
   // Parse and store the server predictions.
   FormStructure::ParseQueryResponse(response_xml,
                                     form_structures_.get(),
                                     *metric_logger_);
 
   // If the corresponding flag is set, annotate forms with the predicted types.
@@ skipping 31 matching lines @@
   const std::vector<AutofillProfile*>& profiles = personal_data_->profiles();
   const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards();
   std::vector<FormGroup*> stored_data;
   stored_data.insert(stored_data.end(), profiles.begin(), profiles.end());
   stored_data.insert(stored_data.end(), credit_cards.begin(),
                      credit_cards.end());
 
   // For each field in the |submitted_form|, extract the value.  Then for each
   // profile or credit card, identify any stored types that match the value.
   for (size_t i = 0; i < submitted_form->field_count(); i++) {
-    const AutofillField* field = submitted_form->field(i);
+    AutofillField* field = submitted_form->field(i);
     string16 value = CollapseWhitespace(field->value, false);
     FieldTypeSet matching_types;
     for (std::vector<FormGroup*>::const_iterator it = stored_data.begin();
          it != stored_data.end(); ++it) {
       (*it)->GetMatchingTypes(value, &matching_types);
     }
 
     if (matching_types.empty())
       matching_types.insert(UNKNOWN_TYPE);
 
-    submitted_form->set_possible_types(i, matching_types);
+    field->set_possible_types(matching_types);
   }
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   const CreditCard* imported_credit_card;
   if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
     return;
 
   // If credit card information was submitted, show an infobar to offer to save
   // it.
@@ skipping 26 matching lines @@
   personal_data_->GetNonEmptyTypes(&non_empty_types);
 
   download_manager_.StartUploadRequest(submitted_form, was_autofilled,
                                        non_empty_types);
 }
 
 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;
 }
 
 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),
       has_logged_autofill_enabled_(false),
-      has_logged_address_suggestions_count_(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)  {
   DCHECK(tab_contents);
 }
 
 void AutofillManager::set_metric_logger(const AutofillMetrics* metric_logger) {
   metric_logger_.reset(metric_logger);
 }
 
 bool AutofillManager::GetHost(const std::vector<AutofillProfile*>& profiles,
                               const std::vector<CreditCard*>& credit_cards,
                               RenderViewHost** host) const {
@@ skipping 277 matching lines @@
   // If none of the forms were parsed, no use querying the server.
   if (!form_structures_.empty() && !disable_download_manager_requests_)
     download_manager_.StartQueryRequest(form_structures_, *metric_logger_);
 
   for (std::vector<FormStructure*>::const_iterator iter =
            non_queryable_forms.begin();
        iter != non_queryable_forms.end(); ++iter) {
     form_structures_.push_back(*iter);
   }
 
+  if (!form_structures_.empty())
+    metric_logger_->LogUserHappinessMetric(AutofillMetrics::FORMS_LOADED);
+
   CheckForPopularForms(form_structures_.get(), tab_contents_wrapper_,
                        tab_contents());
 }
 
 int AutofillManager::GUIDToID(const GUIDPair& guid) {
   static int last_id = 1;
 
   if (!guid::IsValidGUID(guid.first))
     return 0;
 
@@ skipping 40 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);
 }