Trigger Password Protection ping on username/password field on focus

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 <stdint.h>
 
 #include <string>
 
@@ skipping 33 matching lines @@
 #include "content/public/test/web_contents_tester.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "extensions/common/constants.h"
 #endif
 
+#if defined(SAFE_BROWSING_DB_LOCAL)
+#include "components/safe_browsing/password_protection/password_protection_service.h"
+#include "components/safe_browsing_db/database_manager.h"
+#endif
+
 using browser_sync::ProfileSyncServiceMock;
 using content::BrowserContext;
 using content::WebContents;
 using sessions::GetPasswordStateFromNavigation;
 using sessions::SerializedNavigationEntry;
 using testing::Return;
 using testing::_;
 
 namespace {
+#if defined(SAFE_BROWSING_DB_LOCAL)
+class FakePasswordProtectionService
+    : public safe_browsing::PasswordProtectionService {
+ public:
+  FakePasswordProtectionService()
+      : PasswordProtectionService(nullptr, nullptr, nullptr, nullptr),
+        called_maybe_start_low_reputation_request_(false) {}
+
+  void FillReferrerChain(
+      const GURL& event_url,
+      int event_tab_id,
+      safe_browsing::LoginReputationClientRequest::Frame* frame) override {}
+
+  bool IsExtendedReporting() override { return true; }
+
+  bool IsIncognito() override { return false; }
+
+  bool IsPingingEnabled() override { return true; }
+
+  void MaybeStartLowReputationRequest(

[dvadym, 2017/04/28 12:14:40]

Nit: Would it be possible to use gmock for mocking this method and using
EXPECT_CALL on it? We are trying to use gmock as much as possible.

[Jialiu Lin, 2017/04/28 18:38:46]

Changed to MOCK methods instead. 

+      const GURL& main_frame_url,
+      const GURL& password_form_action,
+      const GURL& password_form_frame_url) override {
+    called_maybe_start_low_reputation_request_ = true;
+  }
+
+  bool called_maybe_start_low_reputation_request() {
+    return called_maybe_start_low_reputation_request_;
+  }
+  ~FakePasswordProtectionService() override {}
+
+ private:
+  bool called_maybe_start_low_reputation_request_;
+  DISALLOW_COPY_AND_ASSIGN(FakePasswordProtectionService);
+};
+#endif
 
 // TODO(vabr): Get rid of the mocked client in the client's own test, see
 // http://crbug.com/474577.
 class MockChromePasswordManagerClient : public ChromePasswordManagerClient {
  public:
   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
 
   explicit MockChromePasswordManagerClient(content::WebContents* web_contents)
       : ChromePasswordManagerClient(web_contents, nullptr) {
     ON_CALL(*this, DidLastPageLoadEncounterSSLErrors())
         .WillByDefault(testing::Return(false));
+#if defined(SAFE_BROWSING_DB_LOCAL)
+    fake_password_protection_service_ =
+        base::MakeUnique<FakePasswordProtectionService>();
+#endif
   }
   ~MockChromePasswordManagerClient() override {}
 
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  safe_browsing::PasswordProtectionService* GetPasswordProtectionService()
+      const override {
+    return fake_password_protection_service_.get();
+  }
+
+  bool called_maybe_start_low_reputation_request() {
+    return fake_password_protection_service_
+        ->called_maybe_start_low_reputation_request();
+  }
+#endif
+
  private:
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  std::unique_ptr<FakePasswordProtectionService>
+      fake_password_protection_service_;
+#endif
   DISALLOW_COPY_AND_ASSIGN(MockChromePasswordManagerClient);
 };
 
 class DummyLogReceiver : public password_manager::LogReceiver {
  public:
   DummyLogReceiver() = default;
 
   void LogSavePasswordProgress(const std::string& text) override {}
 
  private:
@@ skipping 462 matching lines @@
   };
 
   for (const TestCase& test_case : kTestCases) {
     // CanShowBubbleOnURL currently only depends on the scheme.
     GURL url(base::StringPrintf("%s://example.org", test_case.scheme));
     SCOPED_TRACE(url.possibly_invalid_spec());
     EXPECT_EQ(test_case.can_show_bubble,
               ChromePasswordManagerClient::CanShowBubbleOnURL(url));
   }
 }
+
+TEST_F(ChromePasswordManagerClientTest,
+       VerifyMaybeStartLowReputationRequestCalled) {
+  std::unique_ptr<WebContents> test_web_contents(
+      content::WebContentsTester::CreateTestWebContents(
+          web_contents()->GetBrowserContext(), nullptr));
+  std::unique_ptr<MockChromePasswordManagerClient> client(
+      new MockChromePasswordManagerClient(test_web_contents.get()));
+  ASSERT_FALSE(client->called_maybe_start_low_reputation_request());
+  client->CheckSafeBrowsingReputation(GURL("http://foo.com/submit"),
+                                      GURL("http://foo.com/iframe.html"));
+  EXPECT_TRUE(client->called_maybe_start_low_reputation_request());
+}