Credential Manager: Stub out call to PasswordStore.

This CL changes the ContentCredentialManagerDispatcher implementation of
requesting credentials to pass the request through the PasswordStore. We
don't yet use the result; we just verify that the callback is called and
passes data around correctly. Baby steps.

BUG=400674

Review URL: https://codereview.chromium.org/615863002

Cr-Commit-Position: refs/heads/master@{#297404}

components/password_manager/content/browser/content_credential_manager_dispatcher.cc

@@ -10,6 +10,7 @@
 #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"
@@ -20,7 +21,8 @@ ContentCredentialManagerDispatcher::ContentCredentialManagerDispatcher(
     content::WebContents* web_contents,
     PasswordManagerClient* client)
     : WebContentsObserver(web_contents),
-      client_(client) {
+      client_(client),
+      pending_request_id_(0) {
   DCHECK(web_contents);
 }
 
@@ -70,17 +72,44 @@ void ContentCredentialManagerDispatcher::OnNotifySignedOut(int request_id) {
 
 void ContentCredentialManagerDispatcher::OnRequestCredential(
     int request_id,
-    bool zero_click_only,
+    bool /* zero_click_only */,
     const std::vector<GURL>& federations) {
-  // TODO(mkwst): This is a stub.
+  DCHECK(request_id);
+  PasswordStore* store = GetPasswordStore();
+  if (pending_request_id_ || !store) {
+    // TODO(mkwst): Reject the promise if we can't get to the password store, or
+    // if we're already requesting credentials.
+  }
+
+  pending_request_id_ = request_id;
+
+  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);
+}
+
+void ContentCredentialManagerDispatcher::OnGetPasswordStoreResults(
+    const std::vector<autofill::PasswordForm*>& results) {
+  DCHECK(pending_request_id_);
+
+  // TODO(mkwst): This is a stub. We should be looking at |results| here. Baby
+  // steps.
   password_manager::CredentialInfo info(base::ASCIIToUTF16("id"),
                                         base::ASCIIToUTF16("name"),
                                         GURL("https://example.com/image.png"));
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_SendCredential(
           web_contents()->GetRenderViewHost()->GetRoutingID(),
-          request_id,
+          pending_request_id_,
           info));
+  pending_request_id_ = 0;
+}
+
+PasswordStore* ContentCredentialManagerDispatcher::GetPasswordStore() {
+  return client_ ? client_->GetPasswordStore() : nullptr;
 }
 
 }  // namespace password_manager

components/password_manager/content/browser/content_credential_manager_dispatcher.h

@@ -7,10 +7,15 @@
 
 #include "base/macros.h"
 #include "components/password_manager/core/browser/credential_manager_dispatcher.h"
+#include "components/password_manager/core/browser/password_store_consumer.h"
 #include "content/public/browser/web_contents_observer.h"
 
 class GURL;
 
+namespace autofill {
+struct PasswordForm;
+}
+
 namespace content {
 class WebContents;
 }
@@ -18,10 +23,12 @@ class WebContents;
 namespace password_manager {
 
 class PasswordManagerClient;
+class PasswordStore;
 struct CredentialInfo;
 
 class ContentCredentialManagerDispatcher : public CredentialManagerDispatcher,
-                                           public content::WebContentsObserver {
+                                           public content::WebContentsObserver,
+                                           public PasswordStoreConsumer {
  public:
   // |client| isn't yet used by this class, but is necessary for the next step:
   // wiring this up as a subclass of PasswordStoreConsumer.
@@ -42,12 +49,23 @@ class ContentCredentialManagerDispatcher : public CredentialManagerDispatcher,
       bool zero_click_only,
       const std::vector<GURL>& federations) OVERRIDE;
 
-  // content::WebContentsObserver overrides.
+  // content::WebContentsObserver implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
+  // PasswordStoreConsumer implementation.
+  virtual void OnGetPasswordStoreResults(
+      const std::vector<autofill::PasswordForm*>& results) OVERRIDE;
+
  private:
+  PasswordStore* GetPasswordStore();
+
   PasswordManagerClient* client_;
 
+  // When 'OnRequestCredential' is called, it in turn calls out to the
+  // PasswordStore; we store the request ID here in order to properly respond
+  // to the request once the PasswordStore gives us data.
+  int pending_request_id_;
+
   DISALLOW_COPY_AND_ASSIGN(ContentCredentialManagerDispatcher);
 };
 

components/password_manager/content/browser/content_credential_manager_dispatcher_unittest.cc

@@ -5,10 +5,13 @@
 #include "components/password_manager/content/browser/content_credential_manager_dispatcher.h"
 
 #include "base/command_line.h"
+#include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.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/stub_password_manager_client.h"
+#include "components/password_manager/core/browser/test_password_store.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_renderer_host.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -22,6 +25,28 @@ namespace {
 // Chosen by fair dice roll. Guaranteed to be random.
 const int kRequestId = 4;
 
+class TestPasswordManagerClient
+    : public password_manager::StubPasswordManagerClient {
+ public:
+  TestPasswordManagerClient(password_manager::PasswordStore* store)
+      : store_(store) {}
+  virtual ~TestPasswordManagerClient() {}
+
+  virtual password_manager::PasswordStore* GetPasswordStore() OVERRIDE {
+    return store_;
+  }
+
+ private:
+  password_manager::PasswordStore* store_;
+};
+
+void RunAllPendingTasks() {
+  base::RunLoop run_loop;
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  run_loop.Run();
+}
+
 }  // namespace
 
 namespace password_manager {
@@ -33,14 +58,23 @@ class ContentCredentialManagerDispatcherTest
 
   virtual void SetUp() OVERRIDE {
     content::RenderViewHostTestHarness::SetUp();
+    store_ = new TestPasswordStore;
+    client_.reset(new TestPasswordManagerClient(store_.get()));
     dispatcher_.reset(
-        new ContentCredentialManagerDispatcher(web_contents(), nullptr));
+        new ContentCredentialManagerDispatcher(web_contents(), client_.get()));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    store_->Shutdown();
+    content::RenderViewHostTestHarness::TearDown();
   }
 
   ContentCredentialManagerDispatcher* dispatcher() { return dispatcher_.get(); }
 
  private:
+  scoped_refptr<TestPasswordStore> store_;
   scoped_ptr<ContentCredentialManagerDispatcher> dispatcher_;
+  scoped_ptr<TestPasswordManagerClient> client_;
 };
 
 TEST_F(ContentCredentialManagerDispatcherTest,
@@ -87,6 +121,8 @@ TEST_F(ContentCredentialManagerDispatcherTest,
   std::vector<GURL> federations;
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
+  RunAllPendingTasks();
+
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);