Fixes for Safe Browsing with unrelated pending navigations.

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 297 matching lines @@
   FakeThreatDetails* get_details() { return details_; }
 
  private:
   FakeThreatDetails* details_;
 };
 
 // A SafeBrowingBlockingPage class that lets us wait until it's hidden.
 class TestSafeBrowsingBlockingPage : public SafeBrowsingBlockingPage {
  public:
   TestSafeBrowsingBlockingPage(SafeBrowsingUIManager* manager,
-                                 WebContents* web_contents,
-                                 const UnsafeResourceList& unsafe_resources)
-      : SafeBrowsingBlockingPage(manager, web_contents, unsafe_resources),
+                               WebContents* web_contents,
+                               const UnsafeResourceList& unsafe_resources,
+                               const GURL& main_frame_url)
+      : SafeBrowsingBlockingPage(manager,
+                                 web_contents,
+                                 unsafe_resources,
+                                 main_frame_url),
         wait_for_delete_(false) {
     // Don't wait the whole 3 seconds for the browser test.
     malware_details_proceed_delay_ms_ = 100;
   }
 
   ~TestSafeBrowsingBlockingPage() override {
     if (!wait_for_delete_)
       return;
 
     // Notify that we are gone
@@ skipping 19 matching lines @@
 
 class TestSafeBrowsingBlockingPageFactory
     : public SafeBrowsingBlockingPageFactory {
  public:
   TestSafeBrowsingBlockingPageFactory() { }
   ~TestSafeBrowsingBlockingPageFactory() override {}
 
   SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
-      const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources)
-      override {
+      const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources,
+      const GURL& main_frame_url) override {
     return new TestSafeBrowsingBlockingPage(delegate, web_contents,
-                                            unsafe_resources);
+                                            unsafe_resources, main_frame_url);
   }
 };
 
 }  // namespace
 
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingBlockingPageBrowserTest
     : public InProcessBrowserTest,
       public testing::WithParamInterface<SBThreatType> {
  public:
@@ skipping 717 matching lines @@
 INSTANTIATE_TEST_CASE_P(SafeBrowsingBlockingPageBrowserTestWithThreatType,
                         SafeBrowsingBlockingPageBrowserTest,
                         testing::Values(SB_THREAT_TYPE_URL_MALWARE,
                                         SB_THREAT_TYPE_URL_PHISHING,
                                         SB_THREAT_TYPE_URL_UNWANTED));
 
 // Test that SafeBrowsingBlockingPage properly decodes IDN URLs that are
 // displayed.
 class SafeBrowsingBlockingPageIDNTest
     : public SecurityInterstitialIDNTest,
-      public testing::WithParamInterface<SBThreatType> {
+      public testing::WithParamInterface<testing::tuple<bool, SBThreatType>> {
  protected:
   // SecurityInterstitialIDNTest implementation
   SecurityInterstitialPage* CreateInterstitial(
       content::WebContents* contents,
       const GURL& request_url) const override {
+    const bool is_subresource = testing::get<0>(GetParam());
+
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
     SafeBrowsingBlockingPage::UnsafeResource resource;
 
     resource.url = request_url;
-    resource.is_subresource = false;
-    resource.threat_type = GetParam();
+    resource.is_subresource = is_subresource;
+    resource.threat_type = testing::get<1>(GetParam());
     resource.render_process_host_id = contents->GetRenderProcessHost()->GetID();
     resource.render_view_id = contents->GetRenderViewHost()->GetRoutingID();
     resource.threat_source = safe_browsing::ThreatSource::LOCAL_PVER3;
 
     return SafeBrowsingBlockingPage::CreateBlockingPage(
-        sb_service->ui_manager().get(), contents, resource);
+        sb_service->ui_manager().get(), contents, resource,
+        is_subresource ? GURL("http://mainframe.example.com/") : request_url);
   }
 };
 
 IN_PROC_BROWSER_TEST_P(SafeBrowsingBlockingPageIDNTest,
                        SafeBrowsingBlockingPageDecodesIDN) {
   EXPECT_TRUE(VerifyIDNDecoded());
 }
 
-INSTANTIATE_TEST_CASE_P(SafeBrowsingBlockingPageIDNTestWithThreatType,
-                        SafeBrowsingBlockingPageIDNTest,
-                        testing::Values(SB_THREAT_TYPE_URL_MALWARE,
-                                        SB_THREAT_TYPE_URL_PHISHING,
-                                        SB_THREAT_TYPE_URL_UNWANTED));
+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