Credential Manager: Wire `notifySignedOut` to the PasswordStore.

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"
 #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 "components/password_manager/core/common/password_manager_pref_names.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 {
 
+// CredentialManagerDispatcher::PendingRequestTask -----------------------------
+
 class CredentialManagerDispatcher::PendingRequestTask
     : public PasswordStoreConsumer {
  public:
   PendingRequestTask(CredentialManagerDispatcher* const dispatcher,
                      int request_id,
                      bool request_zero_click_only,
                      const GURL& request_origin,
                      const std::vector<GURL>& request_federations)
       : dispatcher_(dispatcher),
         id_(request_id),
@@ skipping 59 matching lines @@
   CredentialManagerDispatcher* const dispatcher_;
 
   const int id_;
   const bool zero_click_only_;
   const GURL origin_;
   std::set<std::string> federations_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingRequestTask);
 };
 
+// CredentialManagerDispatcher::PendingSignedOutTask ---------------------------
+
+class CredentialManagerDispatcher::PendingSignedOutTask
+    : public PasswordStoreConsumer {
+ public:
+  PendingSignedOutTask(CredentialManagerDispatcher* const dispatcher,

[vasilii, 2015/02/05 14:49:31]

'const' doesn't make a lot of sense here.

+                       int request_id,
+                       const GURL& origin);
+
+  // PasswordStoreConsumer implementation.
+  void OnGetPasswordStoreResults(
+      const std::vector<autofill::PasswordForm*>& results) override;
+
+ private:
+  // Backlink to the CredentialManagerDispatcher that owns this object.
+  CredentialManagerDispatcher* const dispatcher_;
+
+  const int id_;
+  const GURL origin_;
+
+  DISALLOW_COPY_AND_ASSIGN(PendingSignedOutTask);
+};
+
+CredentialManagerDispatcher::PendingSignedOutTask::PendingSignedOutTask(
+    CredentialManagerDispatcher* const dispatcher,
+    int request_id,
+    const GURL& origin)
+    : dispatcher_(dispatcher), id_(request_id), origin_(origin) {
+}
+
+void CredentialManagerDispatcher::PendingSignedOutTask::
+    OnGetPasswordStoreResults(
+        const std::vector<autofill::PasswordForm*>& results) {
+  // We own the PasswordForm instances, so we're responsible for cleaning
+  // up the instances we don't add to |updating| (which will delete itself).
+  PasswordStore* store = dispatcher_->GetPasswordStore();
+  ScopedVector<autofill::PasswordForm> updating;
+  for (autofill::PasswordForm* form : results) {
+    if (form->origin == origin_) {
+      form->skip_zero_click = true;
+      store->UpdateLogin(*form);
+      updating.push_back(form);
+    } else {
+      delete form;

[vabr (Chromium), 2015/02/05 14:08:40]

Why not just delete them all directly? UpdateLogin takes a copy of the form
anyway.

[vasilii, 2015/02/05 14:49:31]

Acknowledged.

+    }
+  }
+}
+
+// CredentialManagerDispatcher -------------------------------------------------
+
 CredentialManagerDispatcher::CredentialManagerDispatcher(
     content::WebContents* web_contents,
     PasswordManagerClient* client)
     : WebContentsObserver(web_contents), client_(client) {
   DCHECK(web_contents);
   auto_signin_enabled_.Init(prefs::kPasswordManagerAutoSignin,
                             client_->GetPrefs());
 }
 
 CredentialManagerDispatcher::~CredentialManagerDispatcher() {
@@ skipping 31 matching lines @@
   DCHECK(request_id);
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_AcknowledgeSignedIn(
           web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
 
   if (!IsSavingEnabledForCurrentPage())
     return;
 
   scoped_ptr<autofill::PasswordForm> form(CreatePasswordFormFromCredentialInfo(
       credential, web_contents()->GetLastCommittedURL().GetOrigin()));
+  form->skip_zero_click = !IsZeroClickAllowed();
 
   // TODO(mkwst): This is a stub; we should be checking the PasswordStore to
   // determine whether or not the credential exists, and calling UpdateLogin
   // accordingly.
   form_manager_.reset(new CredentialManagerPasswordFormManager(
       client_, GetDriver(), *form, this));
 }
 
 void CredentialManagerDispatcher::OnProvisionalSaveComplete() {
   DCHECK(form_manager_);
   client_->PromptUserToSavePassword(form_manager_.Pass());
 }
 
 void CredentialManagerDispatcher::OnNotifySignedOut(int request_id) {
   DCHECK(request_id);
-  // TODO(mkwst): This is a stub.
+
+  PasswordStore* store = GetPasswordStore();
+  if (!pending_sign_out_ && store) {

[vasilii, 2015/02/05 14:49:31]

I don't see the place where pending_sign_out_ actually becomes NULL.

+    pending_sign_out_.reset(new PendingSignedOutTask(
+        this, request_id, web_contents()->GetLastCommittedURL().GetOrigin()));
+
+    // This will result in a callback to
+    // PendingSignedOutTask::OnGetPasswordStoreResults().
+    store->GetAutofillableLogins(pending_sign_out_.get());
+  }
+
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_AcknowledgeSignedOut(
           web_contents()->GetRenderViewHost()->GetRoutingID(), request_id));
 }
 
 void CredentialManagerDispatcher::OnRequestCredential(
     int request_id,
     bool zero_click_only,
     const std::vector<GURL>& federations) {
   DCHECK(request_id);
@@ skipping 45 matching lines @@
   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);
+  // TODO(mkwst): We need to update the underlying PasswordForm if the user
+  // has enabled zeroclick globally, and clicks through a non-zeroclick form
+  // for an origin.
   web_contents()->GetRenderViewHost()->Send(
       new CredentialManagerMsg_SendCredential(
           web_contents()->GetRenderViewHost()->GetRoutingID(),
           pending_request_->id(), info));
   pending_request_.reset();
 }
 
 }  // namespace password_manager