Update the |skip_zero_click| flag of a credential when selected in the account chooser.

components/password_manager/content/browser/credential_manager_dispatcher.cc

 // Copyright 2014 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/password_manager/content/browser/credential_manager_dispatcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
@@ skipping 207 matching lines @@
   PasswordManagerDriver* driver =
       driver_factory->GetDriverForFrame(web_contents()->GetMainFrame());
   return driver->AsWeakPtr();
 }
 
 void CredentialManagerDispatcher::SendCredential(int request_id,
                                                  const CredentialInfo& info) {
   DCHECK(pending_request_);
   DCHECK_EQ(pending_request_->id(), request_id);
 
-  if (PasswordStore* store = GetPasswordStore()) {
-    if (info.type != CredentialType::CREDENTIAL_TYPE_EMPTY &&
-        IsZeroClickAllowed()) {
-      DCHECK(IsUpdatingCredentialAllowed());
-      scoped_ptr<autofill::PasswordForm> form(
-          CreatePasswordFormFromCredentialInfo(info,
-                                               pending_request_->origin()));
-      form->skip_zero_click = false;
-      store->UpdateLogin(*form);
-    }
-  }
-
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_SendCredential(
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           pending_request_->id(), info));
   pending_request_.reset();
 }
 
+void CredentialManagerDispatcher::SendPasswordForm(
+    int request_id,
+    const autofill::PasswordForm* form) {
+  CredentialInfo info;
+  if (form) {
+    password_manager::CredentialType type_to_return =
+        form->federation_origin.unique()
+            ? CredentialType::CREDENTIAL_TYPE_PASSWORD
+            : CredentialType::CREDENTIAL_TYPE_FEDERATED;
+    info = CredentialInfo(*form, type_to_return);
+    if (PasswordStore* store = GetPasswordStore()) {
+      if (form->skip_zero_click && IsZeroClickAllowed()) {
+        DCHECK(IsUpdatingCredentialAllowed());
+        autofill::PasswordForm update_form = *form;
+        update_form.skip_zero_click = false;
+        store->UpdateLogin(update_form);
+      }
+    }
+  }
+  SendCredential(request_id, info);
+}
+
 PasswordManagerClient* CredentialManagerDispatcher::client() const {
   return client_;
 }
 
 autofill::PasswordForm
 CredentialManagerDispatcher::GetSynthesizedFormForOrigin() const {
   autofill::PasswordForm synthetic_form;
   synthetic_form.origin = web_contents()->GetLastCommittedURL().GetOrigin();
   synthetic_form.signon_realm = synthetic_form.origin.spec();
   synthetic_form.scheme = autofill::PasswordForm::SCHEME_HTML;
   synthetic_form.ssl_valid = synthetic_form.origin.SchemeIsCryptographic() &&
                              !client_->DidLastPageLoadEncounterSSLErrors();
   return synthetic_form;
 }
 
 void CredentialManagerDispatcher::DoneRequiringUserMediation() {
   DCHECK(pending_require_user_mediation_);
   pending_require_user_mediation_.reset();
 }
 
 bool CredentialManagerDispatcher::IsUpdatingCredentialAllowed() const {
   return !client_->DidLastPageLoadEncounterSSLErrors() &&
          !client_->IsOffTheRecord();
 }
 
 }  // namespace password_manager