Add autofill metrics to dig into the failure case.

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 <map>
 #include <set>
 #include <utility>
@@ skipping 191 matching lines @@
   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();
+  FormStructure* cached_upload_form_structure = NULL;
+  AutoFillField* ignored;
+  if (!FindCachedFormAndField(form, form.fields.front(),
+                              &cached_upload_form_structure, &ignored)) {
+    cached_upload_form_structure = NULL;
+  }
+
+  DeterminePossibleFieldTypesForUpload(cached_upload_form_structure);
   // TODO(isherman): Consider uploading to server here rather than in
   // HandleSubmit().
 
   if (!upload_form_structure_->IsAutoFillable(true))
     return;
 
   HandleSubmit();
 }
 
 void AutoFillManager::OnFormsSeen(const std::vector<FormData>& forms) {
@@ skipping 256 matching lines @@
   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::DeterminePossibleFieldTypesForUpload() {
+void AutoFillManager::DeterminePossibleFieldTypesForUpload(
+    const FormStructure* cached_upload_form_structure) {
   for (size_t i = 0; i < upload_form_structure_->field_count(); i++) {
     const AutoFillField* field = upload_form_structure_->field(i);
     FieldTypeSet field_types;
     GetPersonalDataManager()->GetPossibleFieldTypes(
         field->value(), &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);
+      if (field->is_autofilled()) {
+        metric_logger_->Log(AutoFillMetrics::FIELD_AUTOFILLED);
+      } else {
+        metric_logger_->Log(AutoFillMetrics::FIELD_AUTOFILL_FAILED);
+
+        AutoFillFieldType heuristic_type = cached_upload_form_structure?
+            cached_upload_form_structure->field(i)->heuristic_type() :
+            UNKNOWN_TYPE;
+        if (heuristic_type == UNKNOWN_TYPE)
+          metric_logger_->Log(AutoFillMetrics::FIELD_HEURISTIC_TYPE_UNKNOWN);
+        else if (field_types.count(heuristic_type))
+          metric_logger_->Log(AutoFillMetrics::FIELD_HEURISTIC_TYPE_MATCH);
+        else
+          metric_logger_->Log(AutoFillMetrics::FIELD_HEURISTIC_TYPE_MISMATCH);
+
+        AutoFillFieldType server_type = cached_upload_form_structure?
+            cached_upload_form_structure->field(i)->server_type() :
+            NO_SERVER_DATA;
+        if (server_type == NO_SERVER_DATA)
+          metric_logger_->Log(AutoFillMetrics::FIELD_SERVER_TYPE_UNKNOWN);
+        else if (field_types.count(server_type))
+          metric_logger_->Log(AutoFillMetrics::FIELD_SERVER_TYPE_MATCH);
+        else
+          metric_logger_->Log(AutoFillMetrics::FIELD_SERVER_TYPE_MISMATCH);
+      }
+
 
       // 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() {
@@ skipping 90 matching lines @@
   return true;
 }
 
 bool AutoFillManager::FindCachedFormAndField(const FormData& form,
                                              const FormField& field,
                                              FormStructure** form_structure,
                                              AutoFillField** autofill_field) {
   // Find the FormStructure that corresponds to |form|.
   *form_structure = NULL;
   for (std::vector<FormStructure*>::const_iterator iter =
-       form_structures_.begin();
+           form_structures_.begin();
        iter != form_structures_.end(); ++iter) {
     if (**iter == form) {
       *form_structure = *iter;
       break;
     }
   }
 
   if (!(*form_structure))
     return false;
 
@@ skipping 139 matching lines @@
              field->max_length() == PhoneNumber::kSuffixLength) {
     number = number.substr(PhoneNumber::kSuffixOffset,
                            PhoneNumber::kSuffixLength);
     field->set_value(number);
   } else {
     field->set_value(number);
   }
 }
 
 void AutoFillManager::ParseForms(const std::vector<FormData>& forms) {
-  std::vector<FormStructure *> non_queryable_forms;
+  std::vector<FormStructure*> non_queryable_forms;
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
     if (!form_structure->ShouldBeParsed(false))
       continue;
 
     // 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_,
-                                        *metric_logger_);
-  }
+  if (!form_structures_.empty() && !disable_download_manager_requests_)
+    download_manager_.StartQueryRequest(form_structures_, *metric_logger_);
 
-  for (std::vector<FormStructure *>::const_iterator iter =
+  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
 // word and profile IDs are sent in the low word.
 int AutoFillManager::PackGUIDs(const std::string& cc_guid,
@@ skipping 42 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;
 }