Safe Browsing phishing interstitial redesign.

chrome/browser/safe_browsing/safe_browsing_blocking_page_v2_test.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.
 //
 // This test creates a fake safebrowsing service, where we can inject
 // malware and phishing urls.  It then uses a real browser to go to
 // these urls, and sends "goback" or "proceed" commands and verifies
 // they work.
 //
 // TODO(mattm): remove / merge this file with
@@ skipping 24 matching lines @@
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/test/test_browser_thread.h"
 
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::NavigationController;
 using content::WebContents;
 
 namespace {
 
+const char kEmptyPage[] = "files/empty.html";
+const char kMalwarePage[] = "files/safe_browsing/malware.html";
+const char kMalwareIframe[] = "files/safe_browsing/malware_iframe.html";
+
 // A SafeBrowingService class that allows us to inject the malicious URLs.
 class FakeSafeBrowsingService :  public SafeBrowsingService {
  public:
   FakeSafeBrowsingService() {}
 
   // Called on the IO thread to check if the given url is safe or not.  If we
   // can synchronously determine that the url is safe, CheckUrl returns true.
   // Otherwise it returns false, and "client" is called asynchronously with the
   // result when it is ready.
   // Overrides SafeBrowsingService::CheckBrowseUrl.
@@ skipping 212 matching lines @@
   void AddURLResult(const GURL& url,
                     SafeBrowsingService::UrlCheckResult checkresult) {
     FakeSafeBrowsingService* service =
         static_cast<FakeSafeBrowsingService*>(
             g_browser_process->safe_browsing_service());
 
     ASSERT_TRUE(service);
     service->AddURLResult(url, checkresult);
   }
 
+  // Adds a safebrowsing result of type |check_result| to the fake safebrowsing
+  // service, navigates to that page, and returns the url.
+  GURL SetupWarningAndNavigate(
+      SafeBrowsingService::UrlCheckResult check_result) {
+    GURL url = test_server()->GetURL(kEmptyPage);
+    AddURLResult(url, check_result);
+
+    ui_test_utils::NavigateToURL(browser(), url);
+    EXPECT_TRUE(WaitForReady());
+    return url;
+  }
+
+  // Adds a safebrowsing malware result to the fake safebrowsing service,
+  // navigates to a page with an iframe containing the malware site, and
+  // returns the url of the parent page.
+  GURL SetupMalwareIframeWarningAndNavigate() {
+    GURL url = test_server()->GetURL(kMalwarePage);
+    GURL iframe_url = test_server()->GetURL(kMalwareIframe);
+    AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
+
+    ui_test_utils::NavigateToURL(browser(), url);
+    EXPECT_TRUE(WaitForReady());
+    return url;
+  }
+
   void SendCommand(const std::string& command) {
     WebContents* contents = chrome::GetActiveWebContents(browser());
     // We use InterstitialPage::GetInterstitialPage(tab) instead of
     // tab->GetInterstitialPage() because the tab doesn't have a pointer
     // to its interstital page until it gets a command from the renderer
     // that it has indeed displayed it -- and this sometimes happens after
     // NavigateToURL returns.
     SafeBrowsingBlockingPage* interstitial_page =
         static_cast<SafeBrowsingBlockingPage*>(
             InterstitialPage::GetInterstitialPage(contents)->
@@ skipping 174 matching lines @@
  protected:
   TestMalwareDetailsFactory details_factory_;
 
  private:
   TestSafeBrowsingServiceFactory factory_;
   TestSafeBrowsingBlockingPageFactory blocking_page_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageV2Test);
 };
 
-const char kEmptyPage[] = "files/empty.html";
-const char kMalwarePage[] = "files/safe_browsing/malware.html";
-const char kMalwareIframe[] = "files/safe_browsing/malware_iframe.html";
-
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        MalwareRedirectInIFrameCanceled) {
   // 1. Test the case that redirect is a subresource.
   MalwareRedirectCancelAndProceed("openWinIFrame");
   // If the redirect was from subresource but canceled, "proceed" will continue
   // with the rest of resources.
   AssertNoInterstitial(true);
 }
 
 // Observed to peridically fail on the ChromeOS tests due to a real
 // use-after-free bug reported by ASan.
 // See crbug.com/145482
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        DISABLED_MalwareRedirectCanceled) {
   // 2. Test the case that redirect is the only resource.
   MalwareRedirectCancelAndProceed("openWin");
   // Clicking proceed won't do anything if the main request is cancelled
   // already.  See crbug.com/76460.
   EXPECT_TRUE(YesInterstitial());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, MalwareDontProceed) {
-  GURL url = test_server()->GetURL(kEmptyPage);
-  AddURLResult(url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  SetupWarningAndNavigate(SafeBrowsingService::URL_MALWARE);
 
   EXPECT_EQ(VISIBLE, GetVisibility("malware-icon"));
   EXPECT_EQ(HIDDEN, GetVisibility("subresource-icon"));
+  EXPECT_EQ(HIDDEN, GetVisibility("phishing-icon"));
   EXPECT_EQ(VISIBLE, GetVisibility("check-report"));
   EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("report-error-link"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
   EXPECT_TRUE(Click("see-more-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("report-error-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("proceed"));
 
   EXPECT_TRUE(ClickAndWaitForDetach("back"));
   AssertNoInterstitial(false);   // Assert the interstitial is gone
   EXPECT_EQ(
-      GURL(chrome::kAboutBlankURL),   // Back to "about:blank"
+      GURL(chrome::kAboutBlankURL),  // Back to "about:blank"
       chrome::GetActiveWebContents(browser())->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, MalwareProceed) {
-  GURL url = test_server()->GetURL(kEmptyPage);
-  AddURLResult(url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  GURL url = SetupWarningAndNavigate(SafeBrowsingService::URL_MALWARE);
 
   EXPECT_TRUE(ClickAndWaitForDetach("proceed"));
-  AssertNoInterstitial(true);    // Assert the interstitial is gone.
+  AssertNoInterstitial(true);  // Assert the interstitial is gone.
   EXPECT_EQ(url, chrome::GetActiveWebContents(browser())->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        MalwareLearnMore) {
-  GURL url = test_server()->GetURL(kEmptyPage);
-  AddURLResult(url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  SetupWarningAndNavigate(SafeBrowsingService::URL_MALWARE);
 
   EXPECT_TRUE(ClickAndWaitForDetach("learn-more-link"));
-  AssertNoInterstitial(false);    // Assert the interstitial is gone
+  AssertNoInterstitial(false);  // Assert the interstitial is gone
 
   // We are in the help page.
   EXPECT_EQ(
       "/goodtoknow/online-safety/malware/",
        chrome::GetActiveWebContents(browser())->GetURL().path());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        MalwareIframeDontProceed) {
-  GURL url = test_server()->GetURL(kMalwarePage);
-  GURL iframe_url = test_server()->GetURL(kMalwareIframe);
-  AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  SetupMalwareIframeWarningAndNavigate();
 
   EXPECT_EQ(HIDDEN, GetVisibility("malware-icon"));
   EXPECT_EQ(VISIBLE, GetVisibility("subresource-icon"));
+  EXPECT_EQ(HIDDEN, GetVisibility("phishing-icon"));
   EXPECT_EQ(VISIBLE, GetVisibility("check-report"));
   EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("report-error-link"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
   EXPECT_TRUE(Click("see-more-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("report-error-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("proceed"));
 
   EXPECT_TRUE(ClickAndWaitForDetach("back"));
   AssertNoInterstitial(false);  // Assert the interstitial is gone
 
   EXPECT_EQ(
-      GURL(chrome::kAboutBlankURL),    // Back to "about:blank"
+      GURL(chrome::kAboutBlankURL),  // Back to "about:blank"
       chrome::GetActiveWebContents(browser())->GetURL());
 }
 
 // Crashy, http://crbug.com/68834.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        DISABLED_MalwareIframeProceed) {
-  GURL url = test_server()->GetURL(kMalwarePage);
-  GURL iframe_url = test_server()->GetURL(kMalwareIframe);
-  AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  GURL url = SetupMalwareIframeWarningAndNavigate();
 
   EXPECT_TRUE(ClickAndWaitForDetach("proceed"));
-  AssertNoInterstitial(true);    // Assert the interstitial is gone
+  AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_EQ(url, chrome::GetActiveWebContents(browser())->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test,
                        MalwareIframeReportDetails) {
-  GURL url = test_server()->GetURL(kMalwarePage);
-  GURL iframe_url = test_server()->GetURL(kMalwareIframe);
-  AddURLResult(iframe_url, SafeBrowsingService::URL_MALWARE);
-
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  GURL url = SetupMalwareIframeWarningAndNavigate();
 
   // If the DOM details from renderer did not already return, wait for them.
   details_factory_.get_details()->WaitForDOM();
 
   EXPECT_TRUE(Click("check-report"));
 
   EXPECT_TRUE(ClickAndWaitForDetach("proceed"));
   AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_TRUE(browser()->profile()->GetPrefs()->GetBoolean(
       prefs::kSafeBrowsingReportingEnabled));
 
   EXPECT_EQ(url, chrome::GetActiveWebContents(browser())->GetURL());
   AssertReportSent();
 }
 
 // Verifies that the "proceed anyway" link isn't available when it is disabled
 // by the corresponding policy. Also verifies that sending the "proceed"
 // command anyway doesn't advance to the malware site.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, ProceedDisabled) {
   // Simulate a policy disabling the "proceed anyway" link.
   browser()->profile()->GetPrefs()->SetBoolean(
       prefs::kSafeBrowsingProceedAnywayDisabled, true);
 
-  GURL url = test_server()->GetURL(kEmptyPage);
-  AddURLResult(url, SafeBrowsingService::URL_MALWARE);
-  ui_test_utils::NavigateToURL(browser(), url);
-  ASSERT_TRUE(WaitForReady());
+  SetupWarningAndNavigate(SafeBrowsingService::URL_MALWARE);
 
   EXPECT_EQ(VISIBLE, GetVisibility("check-report"));
   EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed-span"));
   EXPECT_TRUE(Click("see-more-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("show-diagnostic-link"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed-span"));
 
   // The "proceed" command should go back instead, if proceeding is disabled.
   EXPECT_TRUE(ClickAndWaitForDetach("proceed"));
   AssertNoInterstitial(true);
   EXPECT_EQ(
-      GURL(chrome::kAboutBlankURL),   // Back to "about:blank"
+      GURL(chrome::kAboutBlankURL),  // Back to "about:blank"
       chrome::GetActiveWebContents(browser())->GetURL());
 }
 
 // Verifies that the reporting checkbox is hidden on non-HTTP pages.
 // TODO(mattm): Should also verify that no report is sent, but there isn't a
 // good way to do that in the current design.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, ReportingDisabled) {
   browser()->profile()->GetPrefs()->SetBoolean(
       prefs::kSafeBrowsingReportingEnabled, true);
 
   net::TestServer https_server(net::TestServer::TYPE_HTTPS,
                                net::TestServer::kLocalhost,
                                FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
   GURL url = https_server.GetURL(kEmptyPage);
   AddURLResult(url, SafeBrowsingService::URL_MALWARE);
   ui_test_utils::NavigateToURL(browser(), url);
   ASSERT_TRUE(WaitForReady());
 
   EXPECT_EQ(HIDDEN, GetVisibility("check-report"));
   EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
   EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
   EXPECT_TRUE(Click("see-more-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("show-diagnostic-link"));
   EXPECT_EQ(VISIBLE, GetVisibility("proceed"));
 
   EXPECT_TRUE(ClickAndWaitForDetach("back"));
   AssertNoInterstitial(false);   // Assert the interstitial is gone
   EXPECT_EQ(
-      GURL(chrome::kAboutBlankURL),   // Back to "about:blank"
+      GURL(chrome::kAboutBlankURL),  // Back to "about:blank"
       chrome::GetActiveWebContents(browser())->GetURL());
 }
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, PhishingDontProceed) {
+  SetupWarningAndNavigate(SafeBrowsingService::URL_PHISHING);
+
+  EXPECT_EQ(HIDDEN, GetVisibility("malware-icon"));
+  EXPECT_EQ(HIDDEN, GetVisibility("subresource-icon"));
+  EXPECT_EQ(VISIBLE, GetVisibility("phishing-icon"));
+  EXPECT_EQ(HIDDEN, GetVisibility("check-report"));
+  EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("report-error-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("proceed"));
+  EXPECT_TRUE(Click("see-more-link"));
+  EXPECT_EQ(HIDDEN, GetVisibility("show-diagnostic-link"));
+  EXPECT_EQ(VISIBLE, GetVisibility("report-error-link"));
+  EXPECT_EQ(VISIBLE, GetVisibility("proceed"));
+
+  EXPECT_TRUE(ClickAndWaitForDetach("back"));
+  AssertNoInterstitial(false);  // Assert the interstitial is gone
+  EXPECT_EQ(
+      GURL(chrome::kAboutBlankURL),  // We are back to "about:blank".
+      chrome::GetActiveWebContents(browser())->GetURL());
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, PhishingProceed) {
+  GURL url = SetupWarningAndNavigate(SafeBrowsingService::URL_PHISHING);
+
+  EXPECT_TRUE(ClickAndWaitForDetach("proceed"));
+  AssertNoInterstitial(true);  // Assert the interstitial is gone
+  EXPECT_EQ(url, chrome::GetActiveWebContents(browser())->GetURL());
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, PhishingReportError) {
+  SetupWarningAndNavigate(SafeBrowsingService::URL_PHISHING);
+
+  EXPECT_TRUE(ClickAndWaitForDetach("report-error-link"));
+  AssertNoInterstitial(false);  // Assert the interstitial is gone
+
+  // We are in the error reporting page.
+  EXPECT_EQ(
+      "/safebrowsing/report_error/",
+      chrome::GetActiveWebContents(browser())->GetURL().path());
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBlockingPageV2Test, PhishingLearnMore) {
+  SetupWarningAndNavigate(SafeBrowsingService::URL_PHISHING);
+
+  EXPECT_TRUE(ClickAndWaitForDetach("learn-more-link"));
+  AssertNoInterstitial(false);  // Assert the interstitial is gone
+
+  // We are in the help page.
+  EXPECT_EQ(
+      "/goodtoknow/online-safety/phishing/",
+       chrome::GetActiveWebContents(browser())->GetURL().path());
+}