Credential Manager: Switch 'request()' to GetAutofillableLogins().

components/password_manager/content/browser/content_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/content_credential_manager_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/content/browser/content_password_manager_driver.h"
 #include "components/password_manager/content/browser/content_password_manager_driver_factory.h"
 #include "components/password_manager/content/browser/credential_manager_password_form_manager.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/content/common/credential_manager_types.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace password_manager {
 
+struct ContentCredentialManagerDispatcher::PendingRequestParameters {
+  PendingRequestParameters(int request_id,
+                           bool request_zero_click_only,
+                           GURL request_origin,
+                           const std::vector<GURL>& request_federations)
+      : id(request_id),
+        zero_click_only(request_zero_click_only),
+        origin(request_origin),
+        federations(request_federations) {}
+
+  int id;
+  bool zero_click_only;
+  GURL origin;
+  std::vector<GURL> federations;
+};
+
 ContentCredentialManagerDispatcher::ContentCredentialManagerDispatcher(
     content::WebContents* web_contents,
     PasswordManagerClient* client)
-    : WebContentsObserver(web_contents),
-      client_(client),
-      pending_request_id_(0) {
+    : WebContentsObserver(web_contents), client_(client) {
   DCHECK(web_contents);
 }
 
 ContentCredentialManagerDispatcher::~ContentCredentialManagerDispatcher() {}
 
 bool ContentCredentialManagerDispatcher::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentCredentialManagerDispatcher, message)
     IPC_MESSAGE_HANDLER(CredentialManagerHostMsg_NotifyFailedSignIn,
@@ skipping 46 matching lines @@
 void ContentCredentialManagerDispatcher::OnNotifySignedOut(int request_id) {
   DCHECK(request_id);
   // TODO(mkwst): This is a stub.
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_AcknowledgeSignedOut(
           web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
 }
 
 void ContentCredentialManagerDispatcher::OnRequestCredential(
     int request_id,
-    bool /* zero_click_only */,
-    const std::vector<GURL>& /* federations */) {
+    bool zero_click_only,
+    const std::vector<GURL>& federations) {
   DCHECK(request_id);
   PasswordStore* store = GetPasswordStore();
-  if (pending_request_id_ || !store) {
+  if (pending_request_ || !store) {
     web_contents()->GetRenderViewHost()->Send(
         new CredentialManagerMsg_RejectCredentialRequest(
-            web_contents()->GetRenderViewHost()->GetRoutingID(),
-            request_id,
-            pending_request_id_
+            web_contents()->GetRenderViewHost()->GetRoutingID(), request_id,
+            pending_request_
                 ? blink::WebCredentialManagerError::ErrorTypePendingRequest
                 : blink::WebCredentialManagerError::
                       ErrorTypePasswordStoreUnavailable));
     return;
   }
 
-  pending_request_id_ = request_id;
+  pending_request_.reset(new PendingRequestParameters(
+      request_id, zero_click_only,
+      web_contents()->GetLastCommittedURL().GetOrigin(), federations));
 
-  // TODO(mkwst): we should deal with federated login types.
-  autofill::PasswordForm form;
-  form.scheme = autofill::PasswordForm::SCHEME_HTML;
-  form.origin = web_contents()->GetLastCommittedURL().GetOrigin();
-  form.signon_realm = form.origin.spec();
-
-  store->GetLogins(form, PasswordStore::DISALLOW_PROMPT, this);
+  store->GetAutofillableLogins(this);
 }
 
 void ContentCredentialManagerDispatcher::OnGetPasswordStoreResults(
     const std::vector<autofill::PasswordForm*>& results) {
-  DCHECK(pending_request_id_);
+  DCHECK(pending_request_);
 
-  if (results.empty() ||
-      !client_->PromptUserToChooseCredentials(results, base::Bind(
-          &ContentCredentialManagerDispatcher::SendCredential,
-          base::Unretained(this),
-          pending_request_id_))) {
-    SendCredential(pending_request_id_, CredentialInfo());
+  std::vector<autofill::PasswordForm*> filtered_results;
+  for (autofill::PasswordForm* form : results) {
+    // TODO(mkwst): Extend this filter to include federations.
+    if (form->origin == pending_request_->origin)
+      filtered_results.push_back(form);
+  }
+
+  if (filtered_results.empty() ||

[vabr (Chromium), 2014/12/15 10:47:22]

An optional "BTW" nit:
It is important that in this if-condition, PromptUserToChooseCredentials remains
always the last one (otherwise we might invoke the prompt for bad origins etc.).
If I were rewriting the code, I would probably separate the first two checks
into their own if-block with an early return, to make that clear. But that's
both just an optional subjective suggestion, and it does not be addressed in
this CL.

[Mike West, 2014/12/15 12:59:24]

I'll take a look at that in the next CL when I poke at the filters again.

+      web_contents()->GetLastCommittedURL().GetOrigin() !=
+          pending_request_->origin ||
+      !client_->PromptUserToChooseCredentials(
+          filtered_results,
+          base::Bind(&ContentCredentialManagerDispatcher::SendCredential,
+                     base::Unretained(this), pending_request_->id))) {
+    SendCredential(pending_request_->id, CredentialInfo());
   }
 }
 
 PasswordStore* ContentCredentialManagerDispatcher::GetPasswordStore() {
   return client_ ? client_->GetPasswordStore() : nullptr;
 }
 
 base::WeakPtr<PasswordManagerDriver>
 ContentCredentialManagerDispatcher::GetDriver() {
   ContentPasswordManagerDriverFactory* driver_factory =
         ContentPasswordManagerDriverFactory::FromWebContents(web_contents());
   DCHECK(driver_factory);
   PasswordManagerDriver* driver =
       driver_factory->GetDriverForFrame(web_contents()->GetMainFrame());
   return driver->AsWeakPtr();
 }
 
 void ContentCredentialManagerDispatcher::SendCredential(
     int request_id, const CredentialInfo& info) {
-  DCHECK(pending_request_id_);
-  DCHECK_EQ(pending_request_id_, request_id);
+  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_id_ = 0;
+          pending_request_->id, info));
+  pending_request_.reset();
 }
 
 }  // namespace password_manager