Wrap SSL error handler configuration with a lazy instance

chrome/browser/captive_portal/captive_portal_browsertest.cc

 // Copyright (c) 2012 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 <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 853 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SSLInterstitialTimerObserver);
 };
 
 SSLInterstitialTimerObserver::SSLInterstitialTimerObserver(
     content::WebContents* web_contents)
     : web_contents_(web_contents),
       message_loop_runner_(new content::MessageLoopRunner) {
   callback_ = base::Bind(&SSLInterstitialTimerObserver::OnTimerStarted,
                          base::Unretained(this));
-  SSLErrorHandler::SetInterstitialTimerStartedCallbackForTest(&callback_);
+  SSLErrorHandler::SetInterstitialTimerStartedCallbackForTesting(&callback_);
 }
 
 SSLInterstitialTimerObserver::~SSLInterstitialTimerObserver() {
-  SSLErrorHandler::SetInterstitialTimerStartedCallbackForTest(nullptr);
+  SSLErrorHandler::SetInterstitialTimerStartedCallbackForTesting(nullptr);
 }
 
 void SSLInterstitialTimerObserver::WaitForTimerStarted() {
   message_loop_runner_->Run();
 }
 
 void SSLInterstitialTimerObserver::OnTimerStarted(
     content::WebContents* web_contents) {
   if (web_contents_ == web_contents && message_loop_runner_.get())
     message_loop_runner_->Quit();
@@ skipping 229 matching lines @@
   EnableCaptivePortalDetection(browser()->profile(), true);
 
   // Set the captive portal service to use URLRequestMockCaptivePortalJob's
   // mock URL, by default.
   SetUpCaptivePortalService(browser()->profile(),
                             GURL(kMockCaptivePortalTestUrl));
 
   // Set SSL interstitial delay long enough so that a captive portal result
   // is guaranteed to arrive during this window, and a captive portal
   // error page is displayed instead of an SSL interstitial.
-  SSLErrorHandler::SetInterstitialDelayForTest(base::TimeDelta::FromHours(1));
+  SSLErrorHandler::SetInterstitialDelayForTesting(
+      base::TimeDelta::FromHours(1));
 }
 
 void CaptivePortalBrowserTest::TearDownOnMainThread() {
   // No test should have a captive portal check pending on quit.
   EXPECT_FALSE(CheckPending(browser()));
 }
 
 void CaptivePortalBrowserTest::SetUpCommandLine(
     base::CommandLine* command_line) {
   // Enable finch experiment for captive portal interstitials.
@@ skipping 1193 matching lines @@
   ASSERT_TRUE(embedded_test_server()->Start());
 
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
 
   // Set SSL interstitial delay to zero so that a captive portal result can not
   // arrive during this window, so an SSL interstitial is displayed instead
   // of a captive portal error page.
-  SSLErrorHandler::SetInterstitialDelayForTest(base::TimeDelta());
+  SSLErrorHandler::SetInterstitialDelayForTesting(base::TimeDelta());
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
 
   // Setting the delay to zero above has a race condition: A captive portal
   // result triggered by a cert error can arrive before the SSL interstitial
   // display timer is fired, even though it's set to zero.
   // To avoid this, disable captive portal checks until the SSL interstitial is
   // displayed. Once it's displayed, enable portal checks and fire one.
   // NOTE: this doesn't occur with PlzNavigate, since the SSL interstitial timer
   // is fired synchronously due to different timings when
@@ skipping 486 matching lines @@
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
             GetStateOfTabReloaderAt(browser(), broken_tab_index));
 
   WaitForInterstitialAttach(broken_tab_contents);
   portal_observer.WaitForResults(1);
 
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
             GetInterstitialType(broken_tab_contents));
 }