Refactoring of upload, form saving, and UMA logging.

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 188 matching lines @@
     return;
 
   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));
+  FormStructure submitted_form(form);
 
   // Disregard forms that we wouldn't ever autofill in the first place.
-  if (!upload_form_structure_->ShouldBeParsed(true))
+  if (!submitted_form.ShouldBeParsed(true))
     return;
 
-  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(&submitted_form);
+  LogMetricsAboutSubmittedForm(form, &submitted_form);
 
-  DeterminePossibleFieldTypesForUpload(cached_upload_form_structure);
-  // TODO(isherman): Consider uploading to server here rather than in
-  // HandleSubmit().

[Ilya Sherman, 2011/01/18 23:02:36]

Are you sure that we should only upload data to the server if our heuristics
detected at least three autofillable fields?  (That's the question this TODO is
really getting at -- should've made it clearer.)

[dhollowa, 2011/01/18 23:26:15]

Yes, typo.  UploadFormData should be moved up above the test for
|IsAutoFillable|.

On 2011/01/18 23:02:36, Ilya Sherman wrote:

[dhollowa, 2011/01/19 17:00:44]

Done.

-
-  if (!upload_form_structure_->IsAutoFillable(true))
+  if (!submitted_form.IsAutoFillable(true))
     return;
 
-  HandleSubmit();
+  ImportFormData(submitted_form);
+  UploadFormData(submitted_form);
 }
 
 void AutoFillManager::OnFormsSeen(const std::vector<FormData>& forms) {
   if (!IsAutoFillEnabled())
     return;
 
   ParseForms(forms);
 }
 
 void AutoFillManager::OnQueryFormFieldAutoFill(
@@ skipping 238 matching lines @@
     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(
-    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);
+    FormStructure* submitted_form) {
+  for (size_t i = 0; i < submitted_form->field_count(); i++) {
+    const AutoFillField* field = submitted_form->field(i);
     FieldTypeSet field_types;
     personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
     DCHECK(!field_types.empty());
-    upload_form_structure_->set_possible_types(i, field_types);
+    submitted_form->set_possible_types(i, field_types);
+  }
+}
+
+void AutoFillManager::LogMetricsAboutSubmittedForm(
+    const FormData& form,
+    const FormStructure* submitted_form) {
+  FormStructure* cached_submitted_form = NULL;
+  AutoFillField* ignored;
+  if (!FindCachedFormAndField(form, form.fields.front(),
+                              &cached_submitted_form, &ignored)) {
+    cached_submitted_form = NULL;

[Ilya Sherman, 2011/01/18 23:02:36]

I wonder if we can make this a NOTREACHED()

[dhollowa, 2011/01/18 23:29:03]

I would think yes, and that would be preferable.  That's not essential to
George's work, but would be nice to clean up.

On 2011/01/18 23:02:36, Ilya Sherman wrote:

+  }
+
+  for (size_t i = 0; i < submitted_form->field_count(); i++) {
+    const AutoFillField* field = submitted_form->field(i);
+    FieldTypeSet field_types;
+    personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
+    DCHECK(!field_types.empty());
 
     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);
 
-        AutoFillFieldType heuristic_type = cached_upload_form_structure?
-            cached_upload_form_structure->field(i)->heuristic_type() :
+        AutoFillFieldType heuristic_type = cached_submitted_form?
+            cached_submitted_form->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() :
+        AutoFillFieldType server_type = cached_submitted_form?
+            cached_submitted_form->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:
       // * 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());
+void AutoFillManager::ImportFormData(const FormStructure& submitted_form) {
+  std::vector<const FormStructure*> import;
+  import.push_back(&submitted_form);
   if (!personal_data_->ImportFormData(import))
     return;
 
   // Did we get credit card info?
   AutoFillProfile* profile;
   CreditCard* credit_card;
   personal_data_->GetImportedFormData(&profile, &credit_card);
 
-  if (!credit_card) {
-    UploadFormData();
-    return;
-  }
-
-  // Show an infobar to offer to save the credit card info.
-  if (tab_contents_) {
+  // If credit card information was submitted, show an infobar to offer to save
+  // it.
+  if (credit_card && tab_contents_) {
     tab_contents_->AddInfoBar(new AutoFillCCInfoBarDelegate(tab_contents_,
                                                             this));
   }
 }
 
-void AutoFillManager::UploadFormData() {
-  if (!disable_download_manager_requests_ && upload_form_structure_.get()) {
+void AutoFillManager::UploadFormData(const FormStructure& submitted_form) {
+  if (!disable_download_manager_requests_) {
     bool was_autofilled = false;
     // Check if the form among last 3 forms that were auto-filled.
     // Clear older signatures.
     std::list<std::string>::iterator it;
     int total_form_checked = 0;
     for (it = autofilled_forms_signatures_.begin();
          it != autofilled_forms_signatures_.end() && total_form_checked < 3;
          ++it, ++total_form_checked) {
-      if (*it == upload_form_structure_->FormSignature())
+      if (*it == submitted_form.FormSignature())
         was_autofilled = true;
     }
     // Remove outdated form signatures.
     if (total_form_checked == 3 && it != autofilled_forms_signatures_.end()) {
       autofilled_forms_signatures_.erase(it,
                                          autofilled_forms_signatures_.end());
     }
-    download_manager_.StartUploadRequest(*(upload_form_structure_.get()),
-                                         was_autofilled);
+    download_manager_.StartUploadRequest(submitted_form, was_autofilled);
   }
 }
 
 void AutoFillManager::Reset() {
-  upload_form_structure_.reset();
   form_structures_.reset();
 }
 
 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_(true),
       metric_logger_(new AutoFillMetrics),
       cc_infobar_(NULL) {
 }
@@ skipping 273 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;
 }