Revert "Revert 223907 "[password generation] Upload possible account cre...""

components/autofill/core/browser/autofill_manager.cc

 // Copyright 2013 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 "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 235 matching lines @@
   // future directions may not need such a pointer.
   external_delegate_ = delegate;
   autocomplete_history_manager_->SetExternalDelegate(delegate);
 }
 
 bool AutofillManager::OnFormSubmitted(const FormData& form,
                                       const TimeTicks& timestamp) {
   // Let Autocomplete know as well.
   autocomplete_history_manager_->OnFormSubmitted(form);
 
-  if (!IsAutofillEnabled())
-    return false;
+  // Grab a copy of the form data.
+  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
 
-  if (driver_->GetWebContents()->GetBrowserContext()->IsOffTheRecord())
+  if (!ShouldUploadForm(*submitted_form))
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return false;
 
-  // Grab a copy of the form data.
-  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
-
-  // Disregard forms that we wouldn't ever autofill in the first place.
-  if (!submitted_form->ShouldBeParsed(true))
-    return false;
-
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return false;
 
   submitted_form->UpdateFromCache(*cached_submitted_form);
   if (submitted_form->IsAutofillable(true))
     ImportFormData(*submitted_form);
 
@@ skipping 489 matching lines @@
   // Always add PASSWORD to |non_empty_types| so that if |submitted_form|
   // contains a password field it will be uploaded to the server. If
   // |submitted_form| doesn't contain a password field, there is no side
   // effect from adding PASSWORD to |non_empty_types|.
   non_empty_types.insert(autofill::PASSWORD);
 
   download_manager_->StartUploadRequest(submitted_form, was_autofilled,
                                         non_empty_types);
 }
 
+bool AutofillManager::UploadPasswordGenerationForm(const FormData& form) {
+  FormStructure form_structure(form);
+
+  if (!ShouldUploadForm(form_structure))
+    return false;
+
+  if (!form_structure.ShouldBeCrowdsourced())
+    return false;
+
+  // TODO(gcasto): Check that PasswordGeneration is enabled?
+
+  // Find the first password field to label. We don't try to label anything
+  // else.
+  bool found_password_field = false;
+  for (size_t i = 0; i < form_structure.field_count(); ++i) {
+    AutofillField* field = form_structure.field(i);
+
+    ServerFieldTypeSet types;
+    if (!found_password_field && field->form_control_type == "password") {
+      types.insert(ACCOUNT_CREATION_PASSWORD);
+      found_password_field = true;
+    } else {
+      types.insert(UNKNOWN_TYPE);
+    }
+    field->set_possible_types(types);
+  }
+  DCHECK(found_password_field);
+
+  // Only one field type should be present.
+  ServerFieldTypeSet available_field_types;
+  available_field_types.insert(ACCOUNT_CREATION_PASSWORD);
+
+  // Force uploading as these events are relatively rare and we want to make
+  // sure to receive them. It also makes testing easier if these requests
+  // always pass.
+  form_structure.set_upload_required(UPLOAD_REQUIRED);
+
+  if (!download_manager_)
+    return false;
+
+  return download_manager_->StartUploadRequest(form_structure,
+                                               false /* was_autofilled */,
+                                               available_field_types);
+}
+
 void AutofillManager::Reset() {
   form_structures_.clear();
   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;
   forms_loaded_timestamp_ = TimeTicks();
   initial_interaction_timestamp_ = TimeTicks();
@@ skipping 333 matching lines @@
 }
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
+bool AutofillManager::ShouldUploadForm(const FormStructure& form) {
+  if (!IsAutofillEnabled())
+    return false;
+
+  if (driver_->GetWebContents()->GetBrowserContext()->IsOffTheRecord())
+    return false;
+
+  // Disregard forms that we wouldn't ever autofill in the first place.
+  if (!form.ShouldBeParsed(true))
+    return false;
+
+  return true;
+}
+
 }  // namespace autofill