Refactor of credential manager dispatcher unittests.

components/password_manager/content/browser/credential_manager_dispatcher_unittest.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/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.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/core/browser/stub_password_manager_client.h"
 #include "components/password_manager/core/browser/stub_password_manager_driver.h"
 #include "components/password_manager/core/browser/test_password_store.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "content/public/browser/web_contents.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 using content::WebContents;
 
+using testing::_;
+
 namespace {
 
 // Chosen by fair dice roll. Guaranteed to be random.
 const int kRequestId = 4;
 
-class TestPasswordManagerClient
+class MockPasswordManagerClient
     : public password_manager::StubPasswordManagerClient {
  public:
-  TestPasswordManagerClient(password_manager::PasswordStore* store)
-      : did_prompt_user_to_save_(false),
-        did_prompt_user_to_choose_(false),
-        did_prompt_auto_signin_(false),
-        is_off_the_record_(false),
-        store_(store) {
+  MOCK_CONST_METHOD0(IsOffTheRecord, bool());
+  MOCK_METHOD1(NotifyUserAutoSigninPtr,
+               bool(const std::vector<autofill::PasswordForm*>& local_forms));
+  MOCK_METHOD2(PromptUserToSavePasswordPtr,
+               void(password_manager::PasswordFormManager*,
+                    password_manager::CredentialSourceType type));
+  MOCK_METHOD4(PromptUserToChooseCredentialsPtr,
+               bool(const std::vector<autofill::PasswordForm*>& local_forms,
+                    const std::vector<autofill::PasswordForm*>& federated_forms,
+                    const GURL& origin,
+                    base::Callback<void(
+                        const password_manager::CredentialInfo&)> callback));
+
+  MockPasswordManagerClient(password_manager::PasswordStore* store)
+      : store_(store) {
     prefs_.registry()->RegisterBooleanPref(
         password_manager::prefs::kPasswordManagerAutoSignin, true);
   }
-  ~TestPasswordManagerClient() override {}
+  ~MockPasswordManagerClient() override {}
+
+  bool PromptUserToSavePassword(
+      scoped_ptr<password_manager::PasswordFormManager> manager,
+      password_manager::CredentialSourceType type) override {
+    manager_.swap(manager);
+    PromptUserToSavePasswordPtr(manager_.get(), type);
+    return true;
+  }
 
   password_manager::PasswordStore* GetPasswordStore() const override {
     return store_;
   }
 
   PrefService* GetPrefs() override { return &prefs_; }
 
-  bool PromptUserToSavePassword(
-      scoped_ptr<password_manager::PasswordFormManager> manager,
-      password_manager::CredentialSourceType type) override {
-    did_prompt_user_to_save_ = true;
-    EXPECT_EQ(password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API,
-              type);
-    manager_.swap(manager);
-    return true;
-  }
-
   bool PromptUserToChooseCredentials(
       ScopedVector<autofill::PasswordForm> local_forms,
       ScopedVector<autofill::PasswordForm> federated_forms,
       const GURL& origin,
-      base::Callback<void(const password_manager::CredentialInfo&)> callback)
-      override {
+      base::Callback<void(const password_manager::CredentialInfo&)> callback) {
     EXPECT_FALSE(local_forms.empty() && federated_forms.empty());
-    did_prompt_user_to_choose_ = true;
     password_manager::CredentialInfo info(
         local_forms.empty() ? *federated_forms[0] : *local_forms[0],
         local_forms.empty()
             ? password_manager::CredentialType::CREDENTIAL_TYPE_FEDERATED
             : password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, info));
+    PromptUserToChooseCredentialsPtr(local_forms.get(), federated_forms.get(),
+                                     origin, callback);
     return true;
   }
 
   void NotifyUserAutoSignin(
       ScopedVector<autofill::PasswordForm> local_forms) override {
     EXPECT_FALSE(local_forms.empty());
-    did_prompt_auto_signin_ = true;
+    NotifyUserAutoSigninPtr(local_forms.get());
   }
 
-  bool IsOffTheRecord() const override { return is_off_the_record_; }
-
-  bool did_prompt_user_to_save() const { return did_prompt_user_to_save_; }
-  bool did_prompt_user_to_choose() const { return did_prompt_user_to_choose_; }
-  bool did_prompt_auto_signin() const { return did_prompt_auto_signin_; }
-
   password_manager::PasswordFormManager* pending_manager() const {
     return manager_.get();
   }
 
-  void set_off_the_record(bool off_the_record) {
-    is_off_the_record_ = off_the_record;
-  }
-
   void set_zero_click_enabled(bool zero_click_enabled) {
     prefs_.SetBoolean(password_manager::prefs::kPasswordManagerAutoSignin,
                       zero_click_enabled);
   }
 
  private:
   TestingPrefServiceSimple prefs_;
-  bool did_prompt_user_to_save_;
-  bool did_prompt_user_to_choose_;
-  bool did_prompt_auto_signin_;
-  bool is_off_the_record_;
   password_manager::PasswordStore* store_;
   scoped_ptr<password_manager::PasswordFormManager> manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestPasswordManagerClient);
+  DISALLOW_COPY_AND_ASSIGN(MockPasswordManagerClient);
 };
 
 class TestCredentialManagerDispatcher
     : public password_manager::CredentialManagerDispatcher {
  public:
   TestCredentialManagerDispatcher(
       content::WebContents* web_contents,
       password_manager::PasswordManagerClient* client,
       password_manager::PasswordManagerDriver* driver);
 
@@ skipping 28 matching lines @@
 namespace password_manager {
 
 class CredentialManagerDispatcherTest
     : public content::RenderViewHostTestHarness {
  public:
   CredentialManagerDispatcherTest() {}
 
   void SetUp() override {
     content::RenderViewHostTestHarness::SetUp();
     store_ = new TestPasswordStore;
-    client_.reset(new TestPasswordManagerClient(store_.get()));
+    client_.reset(new MockPasswordManagerClient(store_.get()));
     dispatcher_.reset(new TestCredentialManagerDispatcher(
         web_contents(), client_.get(), &stub_driver_));
+    ON_CALL(*client_, IsOffTheRecord()).WillByDefault(testing::Return(false));
 
     NavigateAndCommit(GURL("https://example.com/test.html"));
 
     form_.username_value = base::ASCIIToUTF16("Username");
     form_.display_name = base::ASCIIToUTF16("Display Name");
     form_.password_value = base::ASCIIToUTF16("Password");
     form_.origin = web_contents()->GetLastCommittedURL().GetOrigin();
     form_.signon_realm = form_.origin.spec();
     form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     form_.skip_zero_click = false;
@@ skipping 23 matching lines @@
     content::RenderViewHostTestHarness::TearDown();
   }
 
   CredentialManagerDispatcher* dispatcher() { return dispatcher_.get(); }
 
  protected:
   autofill::PasswordForm form_;
   autofill::PasswordForm form2_;
   autofill::PasswordForm cross_origin_form_;
   scoped_refptr<TestPasswordStore> store_;
-  scoped_ptr<TestPasswordManagerClient> client_;
+  scoped_ptr<MockPasswordManagerClient> client_;
   StubPasswordManagerDriver stub_driver_;
   scoped_ptr<CredentialManagerDispatcher> dispatcher_;
 };
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifyFailedSignIn) {
   CredentialInfo info;
   info.type = CredentialType::CREDENTIAL_TYPE_LOCAL;
   dispatcher()->OnNotifyFailedSignIn(kRequestId, info);
 
   const uint32 kMsgID = CredentialManagerMsg_AcknowledgeFailedSignIn::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 }
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifySignedIn) {
   CredentialInfo info(form_,
                       password_manager::CredentialType::CREDENTIAL_TYPE_LOCAL);
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(1));
+
   dispatcher()->OnNotifySignedIn(kRequestId, info);
 
   const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   // Allow the PasswordFormManager to talk to the password store, determine
   // that the form is new, and set it as pending.
   RunAllPendingTasks();
 
-  EXPECT_TRUE(client_->did_prompt_user_to_save());
   EXPECT_TRUE(client_->pending_manager()->HasCompletedMatching());
 
   autofill::PasswordForm new_form =
       client_->pending_manager()->pending_credentials();
   EXPECT_EQ(form_.username_value, new_form.username_value);
   EXPECT_EQ(form_.display_name, new_form.display_name);
   EXPECT_EQ(form_.password_value, new_form.password_value);
   EXPECT_EQ(form_.origin, new_form.origin);
   EXPECT_EQ(form_.signon_realm, new_form.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, new_form.scheme);
 }
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerIncognitoSignedIn) {
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_LOCAL);
-  client_->set_off_the_record(true);
+  EXPECT_CALL(*client_, IsOffTheRecord()).WillRepeatedly(testing::Return(true));
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+
   dispatcher()->OnNotifySignedIn(kRequestId, info);
 
   const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   RunAllPendingTasks();
 
-  EXPECT_FALSE(client_->did_prompt_user_to_save());
   EXPECT_FALSE(client_->pending_manager());
 }
 
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifySignedOut) {
   store_->AddLogin(form_);
   store_->AddLogin(cross_origin_form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
@@ skipping 15 matching lines @@
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_FALSE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithEmptyPasswordStore) {
   std::vector<GURL> federations;
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
   process()->sink().ClearMessages();
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          testing::_,

[vabr (Chromium), 2015/03/30 09:02:30]

nit: testing::_ -> _

[melandory, 2015/03/30 09:22:42]

Done.

+          password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
   process()->sink().ClearMessages();
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithFullPasswordStore) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_TRUE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
 }
 
 TEST_F(
     CredentialManagerDispatcherTest,
     CredentialManagerOnRequestCredentialWithZeroClickOnlyEmptyPasswordStore) {
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyFullPasswordStore) {
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(1));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_TRUE(client_->did_prompt_auto_signin());
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyTwoPasswordStore) {
   store_->AddLogin(form_);
   store_->AddLogin(form2_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
   // With two items in the password store, we shouldn't get credentials back.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        OnRequestCredentialWithZeroClickOnlyOnePasswordStore) {
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
   store_->AddLogin(form2_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(1));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_TRUE(client_->did_prompt_auto_signin());
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
   // We should get |form2_| back, as |form_| is marked as skipping zero-click.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_LOCAL, get<1>(send_param).type);
   EXPECT_EQ(form2_.username_value, get<1>(send_param).id);
   EXPECT_EQ(form2_.display_name, get<1>(send_param).name);
   EXPECT_EQ(form2_.password_value, get<1>(send_param).password);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        OnRequestCredentialWithZeroClickOnlyCrossOriginPasswordStore) {
   store_->AddLogin(cross_origin_form_);
 
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
 
   // We only have cross-origin zero-click credentials; they should not be
   // returned.
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWhileRequestPending) {
   client_->set_zero_click_enabled(false);
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
 
   // Check that the second request triggered a rejection.
   uint32 kMsgID = CredentialManagerMsg_RejectCredentialRequest::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))

[vabr (Chromium), 2015/03/30 09:02:30]

If I understand GMock correctly, the .Times(0) expectation from lines 515-518 is
still in effect through this whole test. So the lines 527-530 seem unnecessary.

[melandory, 2015/03/30 09:22:42]

Done.

+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   CredentialManagerMsg_RejectCredentialRequest::Param reject_param;
   CredentialManagerMsg_RejectCredentialRequest::Read(message, &reject_param);
   EXPECT_EQ(blink::WebCredentialManagerError::ErrorTypePendingRequest,
             get<1>(reject_param));
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
 
   process()->sink().ClearMessages();
 
   // Execute the PasswordStore asynchronousness.
   RunAllPendingTasks();
 
   // Check that the first request resolves.
   kMsgID = CredentialManagerMsg_SendCredential::ID;
   message = process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param send_param;
   CredentialManagerMsg_SendCredential::Read(message, &send_param);
   EXPECT_NE(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(send_param).type);
   process()->sink().ClearMessages();
-  EXPECT_TRUE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
 }
 
 TEST_F(CredentialManagerDispatcherTest, ResetSkipZeroClickAfterPrompt) {
   // Turn on the global zero-click flag, and add two credentials in separate
   // origins, both set to skip zero-click.
   client_->set_zero_click_enabled(true);
   form_.skip_zero_click = true;
   store_->AddLogin(form_);
   cross_origin_form_.skip_zero_click = true;
   store_->AddLogin(cross_origin_form_);
 
   // Execute the PasswordStore asynchronousness to ensure everything is
   // written before proceeding.
   RunAllPendingTasks();
 
   // Sanity check.
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_TRUE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 
   // Trigger a request which should return the credential found in |form_|, and
   // wait for it to process.
   std::vector<GURL> federations;
+  // Check that the form in the database has been updated. `OnRequestCredential`
+  // generates a call to prompt the user to choose a credential.
+  // MockPasswordManagerClient mocks a user choice, and when users choose a
+  // credential (and have the global zero-click flag enabled), we make sure that
+  // they'll be logged in again next time.
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, false, federations);
   RunAllPendingTasks();
 
-  // Check that the form in the database has been updated. `OnRequestCredential`
-  // generates a call to prompt the user to choose a credential.
-  // TestPasswordManagerClient mocks a user choice, and when users choose a
-  // credential (and have the global zero-click flag enabled), we make sure that
-  // they'll be logged in again next time.
-  EXPECT_TRUE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
   passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
   EXPECT_TRUE(passwords[cross_origin_form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerDispatcherTest, IncognitoZeroClickRequestCredential) {
-  client_->set_off_the_record(true);
+  EXPECT_CALL(*client_, IsOffTheRecord()).WillRepeatedly(testing::Return(true));
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(0));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
   dispatcher()->OnRequestCredential(kRequestId, true, federations);
 
   RunAllPendingTasks();
 
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   ASSERT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
-  EXPECT_FALSE(client_->did_prompt_user_to_choose());
-  EXPECT_FALSE(client_->did_prompt_auto_signin());
 }
 
 }  // namespace password_manager