Simplify SafeBrowsingBlockingPageBrowserTest.IframeOptInAndReportThreatDetails

chrome/browser/safe_browsing/safe_browsing_blocking_page_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 known-
 // threat urls.  It then uses a real browser to go to these urls, and sends
 // "goback" or "proceed" commands and verifies they work.
 
 #include <algorithm>
 
@@ skipping 50 matching lines @@
 using content::NavigationController;
 using content::RenderFrameHost;
 using content::WebContents;
 
 namespace safe_browsing {
 
 namespace {
 
 const char kEmptyPage[] = "empty.html";
 const char kHTTPSPage[] = "/ssl/google.html";
-const char kMalwarePage[] = "safe_browsing/malware.html";
-const char kCrossSiteMalwarePage[] = "safe_browsing/malware2.html";
-const char kMalwareIframe[] = "safe_browsing/malware_iframe.html";
-const char kCrossSiteIframeUrl[] = "http://example.com/cross_site_iframe.html";
+const char kMaliciousPage[] = "safe_browsing/malware.html";
+const char kCrossSiteMaliciousPage[] = "safe_browsing/malware2.html";
+const char kMaliciousIframe[] = "safe_browsing/malware_iframe.html";
 const char kUnrelatedUrl[] = "https://www.google.com";
 
 // A SafeBrowsingDatabaseManager class that allows us to inject the malicious
 // URLs.
 class FakeSafeBrowsingDatabaseManager : public TestSafeBrowsingDatabaseManager {
  public:
   FakeSafeBrowsingDatabaseManager() {}
 
   // 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.
@@ skipping 277 matching lines @@
                                           ->GetInterstitialPage();
     EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
               https_warning->GetDelegateForTesting()->GetTypeForTesting());
     https_warning->Proceed();
     content::WaitForInterstitialDetach(
         browser()->tab_strip_model()->GetActiveWebContents());
 
     return SetupWarningAndNavigateToURL(url);
   }
 
-  // Adds two safebrowsing threat results to the fake safebrowsing service,
-  // navigates to a page with an iframe containing the threat site, and another
-  // cross site iframe containing another threat site, and returns the url of
-  // the parent page.
+  // Adds a safebrowsing threat results to the fake safebrowsing service,
+  // navigates to a page with an iframe containing the threat site, and returns
+  // the url of the parent page.
   GURL SetupThreatIframeWarningAndNavigate() {
-    GURL url = net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMalwarePage);
-    GURL iframe_url = net::URLRequestMockHTTPJob::GetMockUrl(kMalwareIframe);
-    GURL cross_site_url(kCrossSiteIframeUrl);
+    GURL url = net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMaliciousPage);
+    GURL iframe_url = net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe);
     SetURLThreatType(iframe_url, testing::get<0>(GetParam()));
-    SetURLThreatType(cross_site_url, testing::get<0>(GetParam()));
 
     ui_test_utils::NavigateToURL(browser(), url);
     EXPECT_TRUE(WaitForReady());
     return url;
   }
 
   void SendCommand(
       security_interstitials::SecurityInterstitialCommands command) {
     WebContents* contents =
         browser()->tab_strip_model()->GetActiveWebContents();
@@ skipping 47 matching lines @@
 
   std::string GetReportSent() {
     return static_cast<FakeSafeBrowsingUIManager*>(
                factory_.test_safe_browsing_service()->ui_manager().get())
         ->GetReport();
   }
 
   void MalwareRedirectCancelAndProceed(const std::string& open_function) {
     GURL load_url = net::URLRequestMockHTTPJob::GetMockUrl(
         "safe_browsing/interstitial_cancel.html");
-    GURL malware_url = net::URLRequestMockHTTPJob::GetMockUrl(kMalwarePage);
+    GURL malware_url = net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousPage);
     SetURLThreatType(malware_url, testing::get<0>(GetParam()));
 
     // Load the test page.
     ui_test_utils::NavigateToURL(browser(), load_url);
     // Trigger the safe browsing interstitial page via a redirect in
     // "openWin()".
     ui_test_utils::NavigateToURLWithDisposition(
         browser(), GURL("javascript:" + open_function + "()"),
         WindowOpenDisposition::CURRENT_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
@@ skipping 221 matching lines @@
   EXPECT_TRUE(ClickAndWaitForDetach("proceed-link"));
   AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_EQ(url,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageBrowserTest,
                        IframeOptInAndReportThreatDetails) {
   // The extended reporting opt-in is presented in the interstitial for malware,
-  // phishing, and UwS threats. This test uses malware as an example to verify
-  // this reporting functionality.
+  // phishing, and UwS threats.
   const bool expect_threat_details =
       SafeBrowsingBlockingPage::ShouldReportThreatDetails(
           testing::get<0>(GetParam()));
 
   scoped_refptr<content::MessageLoopRunner> threat_report_sent_runner(
       new content::MessageLoopRunner);
   if (expect_threat_details)
     SetReportSentCallback(threat_report_sent_runner->QuitClosure());
 
   // Set up testing url containing iframe and cross site iframe.
@@ skipping 13 matching lines @@
 
   if (expect_threat_details) {
     threat_report_sent_runner->Run();
     std::string serialized = GetReportSent();
     ClientSafeBrowsingReportRequest report;
     ASSERT_TRUE(report.ParseFromString(serialized));
     // Verify the report is complete.
     EXPECT_TRUE(report.complete());
     // Do some basic verification of report contents.
     EXPECT_EQ(url.spec(), report.page_url());
-    EXPECT_EQ(net::URLRequestMockHTTPJob::GetMockUrl(kMalwareIframe).spec(),
+    EXPECT_EQ(net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe).spec(),
               report.url());
     std::vector<ClientSafeBrowsingReportRequest::Resource> resources;
     for (auto resource: report.resources()) {
       resources.push_back(resource);
     }
     // Sort resources based on their urls.
     std::sort(resources.begin(), resources.end(),
               [](const ClientSafeBrowsingReportRequest::Resource& a,
                  const ClientSafeBrowsingReportRequest::Resource& b) -> bool {
                 return a.url() < b.url();
               });
-    ASSERT_EQ(3U, resources.size());
+    ASSERT_EQ(2U, resources.size());
     VerifyResource(
-        report, resources[0], kCrossSiteIframeUrl,
-        net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMalwarePage).spec(), 0,
-        "IFRAME");
+        report, resources[0],
+        net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMaliciousPage).spec(),
+        net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMaliciousPage).spec(),
+        1, "");
     VerifyResource(
         report, resources[1],
-        net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMalwarePage).spec(),
-        net::URLRequestMockHTTPJob::GetMockUrl(kCrossSiteMalwarePage).spec(), 2,
-        "");
-    VerifyResource(
-        report, resources[2],
-        net::URLRequestMockHTTPJob::GetMockUrl(kMalwareIframe).spec(),
-        url.spec(),  // kCrossSiteMalwarePage
+        net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousIframe).spec(),
+        url.spec(),  // kCrossSiteMaliciousPage
         0, "IFRAME");
   }
 }
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageBrowserTest,
                        MainFrameBlockedShouldHaveNoDOMDetailsWhenDontProceed) {
   const bool expect_threat_details =
       SafeBrowsingBlockingPage::ShouldReportThreatDetails(
           testing::get<0>(GetParam()));
 
   scoped_refptr<content::MessageLoopRunner> threat_report_sent_runner(
       new content::MessageLoopRunner);
   if (expect_threat_details)
     SetReportSentCallback(threat_report_sent_runner->QuitClosure());
 
   // Navigate to a safe page which contains multiple potential DOM details.
-  // (Despite the name, kMalwarePage is not the page flagged as malware in this
+  // (Despite the name, kMaliciousPage is not the page flagged as bad in this
   // test.)
-  GURL safe_url(net::URLRequestMockHTTPJob::GetMockUrl(kMalwarePage));
+  GURL safe_url(net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousPage));
   ui_test_utils::NavigateToURL(browser(), safe_url);
 
   EXPECT_EQ(nullptr, details_factory_.get_details());
 
   // Start navigation to bad page (kEmptyPage), which will be blocked before it
   // is committed.
   GURL url = SetupWarningAndNavigate();
 
   ThreatDetails* threat_details = details_factory_.get_details();
   EXPECT_EQ(expect_threat_details, threat_details != nullptr);
@@ skipping 29 matching lines @@
   const bool expect_threat_details =
       SafeBrowsingBlockingPage::ShouldReportThreatDetails(
           testing::get<0>(GetParam()));
 
   scoped_refptr<content::MessageLoopRunner> threat_report_sent_runner(
       new content::MessageLoopRunner);
   if (expect_threat_details)
     SetReportSentCallback(threat_report_sent_runner->QuitClosure());
 
   // Navigate to a safe page which contains multiple potential DOM details.
-  // (Despite the name, kMalwarePage is not the page flagged as malware in this
+  // (Despite the name, kMaliciousPage is not the page flagged as bad in this
   // test.)
   ui_test_utils::NavigateToURL(
-      browser(), net::URLRequestMockHTTPJob::GetMockUrl(kMalwarePage));
+      browser(), net::URLRequestMockHTTPJob::GetMockUrl(kMaliciousPage));
 
   EXPECT_EQ(nullptr, details_factory_.get_details());
 
   // Start navigation to bad page (kEmptyPage), which will be blocked before it
   // is committed.
   GURL url = SetupWarningAndNavigate();
 
   ThreatDetails* threat_details = details_factory_.get_details();
   EXPECT_EQ(expect_threat_details, threat_details != nullptr);
 
@@ skipping 328 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     SafeBrowsingBlockingPageIDNTestWithThreatType,
     SafeBrowsingBlockingPageIDNTest,
     testing::Combine(testing::Values(false, true),
                      testing::Values(SB_THREAT_TYPE_URL_MALWARE,
                                      SB_THREAT_TYPE_URL_PHISHING,
                                      SB_THREAT_TYPE_URL_UNWANTED)));
 
 }  // namespace safe_browsing