Add some basic success/failure UMA logging for autofill.

chrome/browser/autofill/autofill_manager.cc

 // Copyright (c) 2010 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 <limits>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_cc_infobar_delegate.h"
 #include "chrome/browser/autofill/autofill_dialog.h"
+#include "chrome/browser/autofill/autofill_metrics.h"
 #include "chrome/browser/autofill/form_structure.h"
 #include "chrome/browser/autofill/phone_number.h"
 #include "chrome/browser/autofill/select_control_handler.h"
 #include "chrome/browser/guid.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ skipping 95 matching lines @@
   return form->source_url().SchemeIs(chrome::kHttpsScheme);
 }
 
 }  // namespace
 
 AutoFillManager::AutoFillManager(TabContents* tab_contents)
     : tab_contents_(tab_contents),
       personal_data_(NULL),
       download_manager_(tab_contents_->profile()),
       disable_download_manager_requests_(false),
+      metric_logger_(new AutoFillMetrics),
       cc_infobar_(NULL) {
   DCHECK(tab_contents);
 
   // |personal_data_| is NULL when using TestTabContents.
   personal_data_ =
       tab_contents_->profile()->GetOriginalProfile()->GetPersonalDataManager();
   download_manager_.SetObserver(this);
 }
 
 AutoFillManager::~AutoFillManager() {
@@ skipping 26 matching lines @@
   if (tab_contents_->profile()->IsOffTheRecord())
     return;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return;
 
   // Grab a copy of the form data.
   upload_form_structure_.reset(new FormStructure(form));
 
+  // Disregard forms that we wouldn't ever autofill in the first place.
+  if (!upload_form_structure_->ShouldBeParsed(true))
+    return;
+
+  DeterminePossibleFieldTypesForUpload();
+  // TODO(isherman): Consider uploading to server here rather than in
+  // HandleSubmit().
+
   if (!upload_form_structure_->IsAutoFillable(true))
     return;
 
-  // Determine the possible field types and upload the form structure to the
-  // PersonalDataManager.
-  DeterminePossibleFieldTypes(upload_form_structure_.get());
   HandleSubmit();
 }
 
 void AutoFillManager::FormsSeen(const std::vector<FormData>& forms) {
   if (!IsAutoFillEnabled())
     return;
 
   ParseForms(forms);
 }
 
@@ skipping 198 matching lines @@
   upload_form_structure_.reset();
   form_structures_.reset();
 }
 
 void AutoFillManager::OnLoadedAutoFillHeuristics(
     const std::string& heuristic_xml) {
   // TODO(jhawkins): Store |upload_required| in the AutoFillManager.
   UploadRequired upload_required;
   FormStructure::ParseQueryResponse(heuristic_xml,
                                     form_structures_.get(),
-                                    &upload_required);
+                                    &upload_required,
+                                    *metric_logger_);
 }
 
 void AutoFillManager::OnUploadedAutoFillHeuristics(
     const std::string& form_signature) {
 }
 
 void AutoFillManager::OnHeuristicsRequestError(
     const std::string& form_signature,
     AutoFillDownloadManager::AutoFillRequestType request_type,
     int http_error) {
 }
 
 bool AutoFillManager::IsAutoFillEnabled() const {
   PrefService* prefs = tab_contents_->profile()->GetPrefs();
 
   // Migrate obsolete AutoFill pref.
   if (prefs->FindPreference(prefs::kFormAutofillEnabled)) {
     bool enabled = prefs->GetBoolean(prefs::kFormAutofillEnabled);
     prefs->ClearPref(prefs::kFormAutofillEnabled);
     prefs->SetBoolean(prefs::kAutoFillEnabled, enabled);
     return enabled;
   }
 
   return prefs->GetBoolean(prefs::kAutoFillEnabled);
 }
 
-void AutoFillManager::DeterminePossibleFieldTypes(
-    FormStructure* form_structure) {
-  for (size_t i = 0; i < form_structure->field_count(); i++) {
-    const AutoFillField* field = form_structure->field(i);
+void AutoFillManager::DeterminePossibleFieldTypesForUpload() {
+  for (size_t i = 0; i < upload_form_structure_->field_count(); i++) {
+    const AutoFillField* field = upload_form_structure_->field(i);
     FieldTypeSet field_types;
     personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
-    form_structure->set_possible_types(i, field_types);
+    DCHECK(!field_types.empty());
+    upload_form_structure_->set_possible_types(i, field_types);
+
+    if (field->form_control_type() == ASCIIToUTF16("select-one")) {
+      // TODO(isherman): <select> fields don't support |is_autofilled()|. Since
+      // this is heavily relied upon by our metrics, we just don't log anything
+      // for all <select> fields. Better to have less data than misleading data.
+      continue;
+    }
+
+    // Log various quality metrics.
+    metric_logger_->Log(AutoFillMetrics::FIELD_SUBMITTED);
+    if (field_types.find(EMPTY_TYPE) == field_types.end() &&
+        field_types.find(UNKNOWN_TYPE) == field_types.end()) {
+      if (field->is_autofilled())
+         metric_logger_->Log(AutoFillMetrics::FIELD_AUTOFILLED);
+      else
+         metric_logger_->Log(AutoFillMetrics::FIELD_AUTOFILL_FAILED);
+
+      // TODO(isherman): Other things we might want to log here:
+      // * Did the field's heuristic type match the PDM type?
+      // * Per Vadim's email, a combination of (1) whether heuristics fired,
+      //   (2) whether the server returned something interesting, (3) whether
+      //   the user filled the field
+      // * Whether the server type matches the heursitic type
+      //   - Perhaps only if at least one of the types is not unknown/no data.
+    }
   }
 }
 
 void AutoFillManager::HandleSubmit() {
   // If there wasn't enough data to import then we don't want to send an upload
   // to the server.
   // TODO(jhawkins): Import form data from |form_structures_|.  That will
   // require querying the FormManager for updated field values.
   std::vector<FormStructure*> import;
   import.push_back(upload_form_structure_.get());
@@ skipping 43 matching lines @@
 void AutoFillManager::OnInfoBarClosed(bool should_save) {
   if (should_save)
     personal_data_->SaveImportedCreditCard();
   UploadFormData();
 }
 
 AutoFillManager::AutoFillManager()
     : tab_contents_(NULL),
       personal_data_(NULL),
       download_manager_(NULL),
-      disable_download_manager_requests_(false),
+      disable_download_manager_requests_(true),
+      metric_logger_(new AutoFillMetrics),
       cc_infobar_(NULL) {
 }
 
 AutoFillManager::AutoFillManager(TabContents* tab_contents,
                                  PersonalDataManager* personal_data)
     : tab_contents_(tab_contents),
       personal_data_(personal_data),
       download_manager_(NULL),
-      disable_download_manager_requests_(false),
+      disable_download_manager_requests_(true),
+      metric_logger_(new AutoFillMetrics),
       cc_infobar_(NULL) {
   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) {
   if (!IsAutoFillEnabled())
     return false;
 
   // No autofill data to return if the profiles are empty.
   if (profiles.empty() && credit_cards.empty())
     return false;
 
@@ skipping 180 matching lines @@
 
     // Set aside forms with method GET so that they are not included in the
     // query to the server.
     if (form_structure->ShouldBeParsed(true))
       form_structures_.push_back(form_structure.release());
     else
       non_queryable_forms.push_back(form_structure.release());
   }
 
   // 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_);
+  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);
   }
 }
 
 // When sending IDs (across processes) to the renderer we pack credit card and
 // profile IDs into a single integer.  Credit card IDs are sent in the high
@@ skipping 44 matching lines @@
     return std::string();
 
   std::map<int, std::string>::const_iterator iter = id_guid_map_.find(id);
   if (iter == id_guid_map_.end()) {
     NOTREACHED();
     return std::string();
   }
 
   return iter->second;
 }