Refactor of password manager client unittests.

chrome/browser/password_manager/chrome_password_manager_client_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 "chrome/browser/password_manager/chrome_password_manager_client.h"
 
 #include "base/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
@@ skipping 10 matching lines @@
 #include "components/password_manager/core/common/password_manager_switches.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 using content::WebContents;
 using testing::Return;
+using testing::_;
 
 namespace {
 
 const char kTestText[] = "abcd1234";
 
 class MockLogReceiver : public password_manager::LogReceiver {
  public:
   MOCK_METHOD1(LogSavePasswordProgress, void(const std::string&));
 };
 
-class TestChromePasswordManagerClient : public ChromePasswordManagerClient {
+class MockChromePasswordManagerClient : public ChromePasswordManagerClient {
  public:
-  explicit TestChromePasswordManagerClient(content::WebContents* web_contents)
-      : ChromePasswordManagerClient(web_contents, nullptr),
-        is_sync_account_credential_(false) {}
-  ~TestChromePasswordManagerClient() override {}
+  MOCK_CONST_METHOD2(IsSyncAccountCredential,
+                     bool(const std::string& username,
+                          const std::string& origin));
 
-  bool IsSyncAccountCredential(const std::string& username,
-                               const std::string& origin) const override {
-    return is_sync_account_credential_;
-  }
-
-  void set_is_sync_account_credential(bool is_sync_account_credential) {
-    is_sync_account_credential_ = is_sync_account_credential;
-  }
+  explicit MockChromePasswordManagerClient(content::WebContents* web_contents)
+      : ChromePasswordManagerClient(web_contents, nullptr) {}
+  ~MockChromePasswordManagerClient() override {}
 
  private:
-  bool is_sync_account_credential_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestChromePasswordManagerClient);
+  DISALLOW_COPY_AND_ASSIGN(MockChromePasswordManagerClient);
 };
 
 }  // namespace
 
 class ChromePasswordManagerClientTest : public ChromeRenderViewHostTestHarness {
  public:
   ChromePasswordManagerClientTest();
 
   virtual void SetUp() override;
 
@@ skipping 150 matching lines @@
 
   service_->UnregisterReceiver(&receiver_);
   EXPECT_FALSE(client->IsLoggingActive());
 }
 
 TEST_F(ChromePasswordManagerClientTest, ShouldFilterAutofillResult_Reauth) {
   // Make client disallow only reauth requests.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(
       password_manager::switches::kDisallowAutofillSyncCredentialForReauth);
-  scoped_ptr<TestChromePasswordManagerClient> client(
-      new TestChromePasswordManagerClient(web_contents()));
+  scoped_ptr<MockChromePasswordManagerClient> client(
+      new MockChromePasswordManagerClient(web_contents()));
   autofill::PasswordForm form;
 
-  client->set_is_sync_account_credential(false);
+  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
+      .WillRepeatedly(Return(false));
   NavigateAndCommit(
       GURL("https://accounts.google.com/login?rart=123&continue=blah"));
   EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
 
-  client->set_is_sync_account_credential(true);
+  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
+      .WillRepeatedly(Return(true));
   NavigateAndCommit(
       GURL("https://accounts.google.com/login?rart=123&continue=blah"));
   EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
 
   // This counts as a reauth url, though a valid URL should have a value for
   // "rart"
   NavigateAndCommit(GURL("https://accounts.google.com/addlogin?rart"));
   EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
 
   NavigateAndCommit(GURL("https://accounts.google.com/login?param=123"));
   EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
 
   NavigateAndCommit(GURL("https://site.com/login?rart=678"));
   EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
 }
 
 TEST_F(ChromePasswordManagerClientTest, ShouldFilterAutofillResult) {
   // Normally the client should allow any credentials through, even if they
   // are the sync credential.
-  scoped_ptr<TestChromePasswordManagerClient> client(
-      new TestChromePasswordManagerClient(web_contents()));
+  scoped_ptr<MockChromePasswordManagerClient> client(
+      new MockChromePasswordManagerClient(web_contents()));
   autofill::PasswordForm form;
-  client->set_is_sync_account_credential(true);
+  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
+      .WillRepeatedly(Return(true));
   NavigateAndCommit(GURL("https://accounts.google.com/Login"));
   EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
 
   // Adding disallow switch should cause sync credential to be filtered.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(
       password_manager::switches::kDisallowAutofillSyncCredential);
-  client.reset(new TestChromePasswordManagerClient(web_contents()));
-  client->set_is_sync_account_credential(true);
+  client.reset(new MockChromePasswordManagerClient(web_contents()));
+  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
+      .WillRepeatedly(Return(true));
   NavigateAndCommit(GURL("https://accounts.google.com/Login"));
   EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
 }
 
 TEST_F(ChromePasswordManagerClientTest,
        IsPasswordManagerEnabledForCurrentPage) {
   ChromePasswordManagerClient* client = GetClient();
   NavigateAndCommit(
       GURL("https://accounts.google.com/ServiceLogin?continue="
            "https://passwords.google.com/settings&rart=123"));
@@ skipping 98 matching lines @@
 
   // Again, without a custom passphrase.
   EXPECT_CALL(*mock_sync_service, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
 
   EXPECT_FALSE(
       client->IsPasswordSyncEnabled(password_manager::ONLY_CUSTOM_PASSPHRASE));
   EXPECT_FALSE(client->IsPasswordSyncEnabled(
       password_manager::WITHOUT_CUSTOM_PASSPHRASE));
 }