Show interstitial on a password on focus ping with PHISHING verdict.

components/safe_browsing/password_protection/password_protection_service_unittest.cc

 // Copyright 2017 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/safe_browsing/password_protection/password_protection_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 60 matching lines @@
       : PasswordProtectionService(database_manager,
                                   request_context_getter,
                                   nullptr,
                                   content_setting_map.get()),
         is_extended_reporting_(true),
         is_incognito_(false),
         latest_request_(nullptr) {}
 
   void RequestFinished(
       PasswordProtectionRequest* request,
+      bool already_cached_unused,
       std::unique_ptr<LoginReputationClientResponse> response) override {
     latest_request_ = request;
     latest_response_ = std::move(response);
   }
 
   // Since referrer chain logic has been thoroughly tested in
   // SBNavigationObserverBrowserTest class, we intentionally leave this function
   // as a no-op here.
   void FillReferrerChain(const GURL& event_url,
                          int event_tab_id,
                          LoginReputationClientRequest::Frame* frame) override {}
 
   bool IsExtendedReporting() override { return is_extended_reporting_; }
 
   bool IsIncognito() override { return is_incognito_; }
 
   void set_extended_reporting(bool enabled) {
     is_extended_reporting_ = enabled;
   }
 
   void set_incognito(bool enabled) { is_incognito_ = enabled; }
 
   bool IsPingingEnabled(const base::Feature& feature,
                         RequestOutcome* reason) override {
     return true;
   }
 
+  void ShowPhishingInterstitial(const GURL& phishing_url,
+                                const std::string& token,
+                                content::WebContents* web_contents) override {}
+
   bool IsHistorySyncEnabled() override { return false; }
 
   LoginReputationClientResponse* latest_response() {
     return latest_response_.get();
   }
 
   ~TestPasswordProtectionService() override {}
 
   size_t GetPendingRequestsCount() { return requests_.size(); }
 
-  LoginReputationClientRequest* GetLatestRequestProto() {
+  const LoginReputationClientRequest* GetLatestRequestProto() {
     return latest_request_ ? latest_request_->request_proto() : nullptr;
   }
 
  private:
   bool is_extended_reporting_;
   bool is_incognito_;
   PasswordProtectionRequest* latest_request_;
   std::unique_ptr<LoginReputationClientResponse> latest_response_;
   DISALLOW_COPY_AND_ASSIGN(TestPasswordProtectionService);
 };
@@ skipping 473 matching lines @@
   LoginReputationClientResponse expected_response = CreateVerdictProto(
       LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
   fetcher.SetResponseString(expected_response.SerializeAsString());
 
   InitializeAndStartPasswordOnFocusRequest(false /* match whitelist */,
                                            100000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
 
-  LoginReputationClientRequest* actual_request =
+  const LoginReputationClientRequest* actual_request =
       password_protection_service_->GetLatestRequestProto();
   EXPECT_EQ(kTargetUrl, actual_request->page_url());
   EXPECT_EQ(LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE,
             actual_request->trigger_type());
   ASSERT_EQ(2, actual_request->frames_size());
   EXPECT_EQ(kTargetUrl, actual_request->frames(0).url());
   EXPECT_EQ(kPasswordFrameUrl, actual_request->frames(1).url());
   EXPECT_EQ(true, actual_request->frames(1).has_password_field());
   ASSERT_EQ(1, actual_request->frames(1).forms_size());
   EXPECT_EQ(kFormActionUrl, actual_request->frames(1).forms(0).action_url());
 }
 
 TEST_F(PasswordProtectionServiceTest,
        VerifyProtectedPasswordEntryRequestProto) {
   // Set up valid response.
   net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);
   fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher.set_response_code(200);
   LoginReputationClientResponse expected_response = CreateVerdictProto(
       LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
   fetcher.SetResponseString(expected_response.SerializeAsString());
   InitializeAndStartPasswordEntryRequest(false /* match whitelist */,
                                          100000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
 
-  LoginReputationClientRequest* actual_request =
+  const LoginReputationClientRequest* actual_request =
       password_protection_service_->GetLatestRequestProto();
   EXPECT_EQ(kTargetUrl, actual_request->page_url());
   EXPECT_EQ(LoginReputationClientRequest::PASSWORD_REUSE_EVENT,
             actual_request->trigger_type());
   EXPECT_EQ(1, actual_request->frames_size());
   EXPECT_EQ(kTargetUrl, actual_request->frames(0).url());
   // TODO(jialiul): Update this test when we're ready to fill more fields.
   ASSERT_FALSE(actual_request->has_password_reuse_event());
 }
 
 }  // namespace safe_browsing