Credential Management: Support zeroclick credential in 'request()'.

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 "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 119 matching lines @@
         new CredentialManagerMsg_SendCredential(
             web_contents()->GetRenderViewHost()->GetRoutingID(), request_id,
             CredentialInfo()));
     return;
   }
 
   pending_request_.reset(new PendingRequestParameters(
       request_id, zero_click_only,
       web_contents()->GetLastCommittedURL().GetOrigin(), federations));
 
+  // This will result in a callback to ::OnGetPasswordStoreResults().
   store->GetAutofillableLogins(this);
 }
 
 void CredentialManagerDispatcher::OnGetPasswordStoreResults(
     const std::vector<autofill::PasswordForm*>& results) {
   DCHECK(pending_request_);
 
   std::set<std::string> federations;
   for (const GURL& origin : pending_request_->federations)
     federations.insert(origin.spec());
 
   // We own the PasswordForm instances, so we're responsible for cleaning
   // up the instances we don't add to |local_results| or |federated_results|.
-  // We'll dump them into a ScopedVector and allow it to delete the
-  // PasswordForms upon destruction.
   std::vector<autofill::PasswordForm*> local_results;
   std::vector<autofill::PasswordForm*> federated_results;
-  ScopedVector<autofill::PasswordForm> discarded_results;
   for (autofill::PasswordForm* form : results) {
-    // TODO(mkwst): Extend this filter to include federations.
     if (form->origin == pending_request_->origin)
       local_results.push_back(form);
     else if (federations.count(form->origin.spec()) != 0)
       federated_results.push_back(form);
     else
-      discarded_results.push_back(form);
+      delete form;
   }
 
   if ((local_results.empty() && federated_results.empty()) ||
       web_contents()->GetLastCommittedURL().GetOrigin() !=
           pending_request_->origin) {
     SendCredential(pending_request_->id, CredentialInfo());
     return;
   }
 
-  if (!client_->PromptUserToChooseCredentials(
-          local_results,
-          federated_results,
+  if (local_results.size() == 1 && IsZeroClickAllowed()) {
+    // TODO(mkwst): Use the `one_time_disable_zero_click` flag on the result
+    // to prevent auto-sign-in, once that flag is implemented.
+    CredentialInfo info(*local_results[0],
+                        local_results[0]->federation_url.is_empty()
+                            ? CredentialType::CREDENTIAL_TYPE_LOCAL
+                            : CredentialType::CREDENTIAL_TYPE_FEDERATED);
+    STLDeleteElements(&local_results);
+    STLDeleteElements(&federated_results);
+    SendCredential(pending_request_->id, info);
+    return;
+  }
+
+  if (pending_request_->zero_click_only ||
+      !client_->PromptUserToChooseCredentials(
+          local_results, federated_results,
           base::Bind(&CredentialManagerDispatcher::SendCredential,
                      base::Unretained(this), pending_request_->id))) {
+    STLDeleteElements(&local_results);
+    STLDeleteElements(&federated_results);
     SendCredential(pending_request_->id, CredentialInfo());
   }
 }
 
 PasswordStore* CredentialManagerDispatcher::GetPasswordStore() {
   return client_ ? client_->GetPasswordStore() : nullptr;
 }
 
 bool CredentialManagerDispatcher::IsSavingEnabledForCurrentPage() const {
   // TODO(vasilii): add more, see http://crbug.com/450583.
   return !client_->IsOffTheRecord();
 }
 
 bool CredentialManagerDispatcher::IsZeroClickAllowed() const {
-  return !client_->IsOffTheRecord();
+  return !client_->IsOffTheRecord() && client_->IsZeroClickEnabled();
 }
 
 base::WeakPtr<PasswordManagerDriver> CredentialManagerDispatcher::GetDriver() {
   ContentPasswordManagerDriverFactory* driver_factory =
       ContentPasswordManagerDriverFactory::FromWebContents(web_contents());
   DCHECK(driver_factory);
   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);
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_SendCredential(
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           pending_request_->id, info));
   pending_request_.reset();
 }
 
 }  // namespace password_manager