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,
+                       const GURL& origin);
+
+  void AddOrigin(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_;
+  std::set<std::string> origins_;
+
+  DISALLOW_COPY_AND_ASSIGN(PendingSignedOutTask);
+};
+
+CredentialManagerDispatcher::PendingSignedOutTask::PendingSignedOutTask(
+    CredentialManagerDispatcher* const dispatcher,
+    const GURL& origin)
+    : dispatcher_(dispatcher) {
+  origins_.insert(origin.spec());
+}
+
+void CredentialManagerDispatcher::PendingSignedOutTask::AddOrigin(
+    const GURL& origin) {
+  origins_.insert(origin.spec());
+}
+
+void CredentialManagerDispatcher::PendingSignedOutTask::
+    OnGetPasswordStoreResults(
+        const std::vector<autofill::PasswordForm*>& results) {
+  PasswordStore* store = dispatcher_->GetPasswordStore();
+  for (autofill::PasswordForm* form : results) {
+    if (origins_.count(form->origin.spec())) {
+      form->skip_zero_click = true;
+      store->UpdateLogin(*form);
+    }
+    // We own the PasswordForms, so we need to dispose of them. This is safe to
+    // do, as ::UpdateLogin ends up copying the form while posting a task to
+    // update the PasswordStore.
+    delete form;
+  }
+
+  dispatcher_->DoneSigningOut();

[vabr (Chromium), 2015/02/06 08:32:32]

optional: Maybe add a note like "Destroys |this|" to make it clear this has to
be the last line of the method.

+}
+
+// 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 (store) {
+    if (!pending_sign_out_) {
+      pending_sign_out_.reset(new PendingSignedOutTask(
+          this, web_contents()->GetLastCommittedURL().GetOrigin()));
+
+      // This will result in a callback to
+      // PendingSignedOutTask::OnGetPasswordStoreResults().
+      store->GetAutofillableLogins(pending_sign_out_.get());
+    } else {
+      pending_sign_out_->AddOrigin(

[vabr (Chromium), 2015/02/06 08:32:32]

I'm just explicitly acknowledging that although there is a short window, when
the password store might get a new credential for the current origin, it is
rather unlikely, that that would happen (hardly through user interaction, maybe
via sync, but that would mean this happens at the right time during start-up).
And if it does happen, the user will probably notice that they are being signed
in again, and repeating the sign-out should stick.

+          web_contents()->GetLastCommittedURL().GetOrigin());
+    }
+  }
+
   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();
 }
 
+void CredentialManagerDispatcher::DoneSigningOut() {
+  DCHECK(pending_sign_out_);
+  pending_sign_out_.reset();
+}
+
 }  // namespace password_manager