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 MockPasswordProtectionService
+    : public safe_browsing::PasswordProtectionService {
+ public:
+  MockPasswordProtectionService()
+      : safe_browsing::PasswordProtectionService(nullptr,
+                                                 nullptr,
+                                                 nullptr,
+                                                 nullptr) {}
+
+  ~MockPasswordProtectionService() override {}
+
+  MOCK_METHOD3(FillReferrerChain,
+               void(const GURL&,
+                    int,
+                    safe_browsing::LoginReputationClientRequest::Frame*));
+  MOCK_METHOD0(IsExtendedReporting, bool());
+  MOCK_METHOD0(IsIncognito, bool());
+  MOCK_METHOD0(IsPingingEnabled, bool());
+  MOCK_METHOD3(MaybeStartLowReputationRequest,
+               void(const GURL&, const GURL&, const GURL&));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockPasswordProtectionService);
+};
+#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)
+    password_protection_service_ =
+        base::MakeUnique<MockPasswordProtectionService>();
+#endif
   }
   ~MockChromePasswordManagerClient() override {}
 
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  safe_browsing::PasswordProtectionService* GetPasswordProtectionService()
+      const override {
+    return password_protection_service_.get();
+  }
+
+  MockPasswordProtectionService* password_protection_service() {
+    return password_protection_service_.get();
+  }
+#endif
+
  private:
+#if defined(SAFE_BROWSING_DB_LOCAL)
+  std::unique_ptr<MockPasswordProtectionService> 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));
   }
 }
+
+#if defined(SAFE_BROWSING_DB_LOCAL)
+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()));
+  EXPECT_CALL(*client->password_protection_service(),
+              MaybeStartLowReputationRequest(_, _, _))
+      .Times(1);
+  client->CheckSafeBrowsingReputation(GURL("http://foo.com/submit"),
+                                      GURL("http://foo.com/iframe.html"));
+}
+#endif