Introduce NavigationSimulator to use in unit tests

components/subresource_filter/content/browser/content_subresource_filter_driver_factory_unittest.cc

 // Copyright 2016 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/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/histogram_tester.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
 #include "components/subresource_filter/core/browser/subresource_filter_client.h"
 #include "components/subresource_filter/core/browser/subresource_filter_features.h"
 #include "components/subresource_filter/core/browser/subresource_filter_features_test_support.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"

[engedy, 2017/03/02 10:38:10]

nit: No longer needed.

[clamy, 2017/03/02 13:11:17]

Done.

 #include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/navigation_simulator.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
+#include "net/base/net_errors.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace subresource_filter {
 
 using ActivationDecision =
     ContentSubresourceFilterDriverFactory::ActivationDecision;
 
 namespace {
 
 const char kExampleUrlWithParams[] = "https://example.com/soceng?q=engsoc";
 const char kExampleUrl[] = "https://example.com";
 const char kExampleLoginUrl[] = "https://example.com/login";
 const char kMatchesPatternHistogramName[] =
     "SubresourceFilter.PageLoad.RedirectChainMatchPattern";
 const char kNavigationChainSize[] =
     "SubresourceFilter.PageLoad.RedirectChainLength";
 const char kUrlA[] = "https://example_a.com";
 const char kUrlB[] = "https://example_b.com";
 const char kUrlC[] = "https://example_c.com";
 const char kUrlD[] = "https://example_d.com";
+const char kSubframeName[] = "Child";
 
 // Human readable representation of expected redirect chain match patterns.
 // The explanations for the buckets given for the following redirect chain:
 // A->B->C->D, where A is initial URL and D is a final URL.
 enum RedirectChainMatchPattern {
   EMPTY,             // No histograms were recorded.
   F0M0L1,            // D is a Safe Browsing match.
   F0M1L0,            // B or C, or both are Safe Browsing matches.
   F0M1L1,            // B or C, or both and D are Safe Browsing matches.
   F1M0L0,            // A is Safe Browsing match
@@ skipping 125 matching lines @@
     RenderViewHostTestHarness::SetUp();
 
     client_ = new MockSubresourceFilterClient();
     ContentSubresourceFilterDriverFactory::CreateForWebContents(
         web_contents(), base::WrapUnique(client()));
 
     // Add a subframe.
     content::RenderFrameHostTester* rfh_tester =
         content::RenderFrameHostTester::For(main_rfh());
     rfh_tester->InitializeRenderFrameIfNeeded();
-    subframe_rfh_ = rfh_tester->AppendChild("Child");
+    subframe_rfh_ = rfh_tester->AppendChild(kSubframeName);
   }
 
   ContentSubresourceFilterDriverFactory* factory() {
     return ContentSubresourceFilterDriverFactory::FromWebContents(
         web_contents());
   }
 
   MockSubresourceFilterClient* client() { return client_; }
   content::RenderFrameHost* subframe_rfh() { return subframe_rfh_; }
 
   void ExpectActivationSignalForFrame(content::RenderFrameHost* rfh,
                                       bool expect_activation) {
     content::MockRenderProcessHost* render_process_host =
         static_cast<content::MockRenderProcessHost*>(rfh->GetProcess());
     const IPC::Message* message =
         render_process_host->sink().GetFirstMessageMatching(
             SubresourceFilterMsg_ActivateForNextCommittedLoad::ID);
     ASSERT_EQ(expect_activation, !!message);
     if (expect_activation) {
       std::tuple<ActivationLevel, bool> args;
       SubresourceFilterMsg_ActivateForNextCommittedLoad::Read(message, &args);
       EXPECT_NE(ActivationLevel::DISABLED, std::get<0>(args));
     }
     render_process_host->sink().ClearMessages();
   }
 
-  void SimulateNavigationCommit(content::RenderFrameHost* rfh,
-                                const GURL& url,
-                                const content::Referrer& referrer,
-                                const ui::PageTransition transition) {
-    // TODO(crbug.com/688393): Once WCO::ReadyToCommitNavigation is invoked
-    // consistently for tests in PlzNavigate and non-PlzNavigate, remove this.
-    if (!content::IsBrowserSideNavigationEnabled()) {
-      factory()->ReadyToCommitNavigationInternal(rfh, url, referrer,
-                                                 transition);
-    }
-    content::RenderFrameHostTester::For(rfh)->SimulateNavigationCommit(url);
-  }
-
   void BlacklistURLWithRedirectsNavigateAndCommit(
       const std::vector<bool>& blacklisted_urls,
       const std::vector<GURL>& navigation_chain,
       safe_browsing::SBThreatType threat_type,
       safe_browsing::ThreatPatternType threat_type_metadata,
       const content::Referrer& referrer,
       ui::PageTransition transition,
       RedirectChainMatchPattern expected_pattern,
       ActivationDecision expected_activation_decision) {
     const bool expected_activation =
         expected_activation_decision == ActivationDecision::ACTIVATED;
     base::HistogramTester tester;
     EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);
-    content::RenderFrameHostTester* rfh_tester =
-        content::RenderFrameHostTester::For(main_rfh());
 
-    rfh_tester->SimulateNavigationStart(navigation_chain.front());
+    std::unique_ptr<content::NavigationSimulator> navigation_simulator =
+        content::NavigationSimulator::CreateRendererInitiated(
+            navigation_chain.front(), main_rfh());
+    navigation_simulator->SetReferrer(referrer);
+    navigation_simulator->SetTransition(transition);
+    navigation_simulator->Start();
+
     if (blacklisted_urls.front()) {
       factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
           navigation_chain.front(), navigation_chain, threat_type,
           threat_type_metadata);
     }
     ::testing::Mock::VerifyAndClearExpectations(client());
 
     for (size_t i = 1; i < navigation_chain.size(); ++i) {
       const GURL url = navigation_chain[i];
       if (i < blacklisted_urls.size() && blacklisted_urls[i]) {
         factory()->OnMainResourceMatchedSafeBrowsingBlacklist(
             url, navigation_chain, threat_type, threat_type_metadata);
       }
-      rfh_tester->SimulateRedirect(url);
+      navigation_simulator->Redirect(url);
     }
 
-    SimulateNavigationCommit(main_rfh(), navigation_chain.back(), referrer,
-                             transition);
+    navigation_simulator->Commit();
     ExpectActivationSignalForFrame(main_rfh(), expected_activation);
     EXPECT_EQ(expected_activation_decision,
               factory()->GetActivationDecisionForLastCommittedPageLoad());
 
+    // Re-create a subframe now that the frame has navigated.
+    content::RenderFrameHostTester* rfh_tester =
+        content::RenderFrameHostTester::For(main_rfh());
+    subframe_rfh_ = rfh_tester->AppendChild(kSubframeName);
+
     if (expected_pattern != EMPTY) {
       EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),
                   ::testing::ElementsAre(base::Bucket(expected_pattern, 1)));
       EXPECT_THAT(
           tester.GetAllSamples(kNavigationChainSize),
           ::testing::ElementsAre(base::Bucket(navigation_chain.size(), 1)));
 
     } else {
       EXPECT_THAT(tester.GetAllSamples(kMatchesPatternHistogramName),
                   ::testing::IsEmpty());
       EXPECT_THAT(tester.GetAllSamples(kNavigationChainSize),
                   ::testing::IsEmpty());
     }
   }
 
   void NavigateAndCommitSubframe(const GURL& url, bool expected_activation) {
     EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);
 
-    content::RenderFrameHostTester::For(subframe_rfh())
-        ->SimulateNavigationStart(url);
-    SimulateNavigationCommit(subframe_rfh(), url, content::Referrer(),
-                             ui::PAGE_TRANSITION_LINK);
+    content::NavigationSimulator::NavigateAndCommitFromDocument(url,
+                                                                subframe_rfh());
+
+    // Update the subframe RFH as the navigation may have lead to a process

[engedy, 2017/03/02 10:38:10]

nit: Given that we need to go hunting for this subframe here anyway, how about
getting rid of |subframe_rfh_| entirely, and moving this block to become the
implementation of subframe_rfh()?

(Alternatively, NavigationSimulator could expose the RFH the simulated
navigation landed in.)

[clamy, 2017/03/02 13:11:17]

I'll go with moving this block. We could have NavigationSimulator expose it
eventually. I'd like to land this ASAP so I'll avoid any modification to the
NavigationSimulator code right now.

+    // swap.
+    for (content::RenderFrameHost* rfh : web_contents()->GetAllFrames()) {
+      if (rfh->GetFrameName() == kSubframeName) {
+        subframe_rfh_ = rfh;
+        break;
+      }
+    }
     ExpectActivationSignalForFrame(subframe_rfh(), expected_activation);
     ::testing::Mock::VerifyAndClearExpectations(client());
   }
 
   void NavigateAndExpectActivation(
       const std::vector<bool>& blacklisted_urls,
       const std::vector<GURL>& navigation_chain,
       safe_browsing::SBThreatType threat_type,
       safe_browsing::ThreatPatternType threat_type_metadata,
       const content::Referrer& referrer,
@@ skipping 25 matching lines @@
   void EmulateDidDisallowFirstSubresourceMessage() {
     factory()->OnMessageReceived(
         SubresourceFilterHostMsg_DidDisallowFirstSubresource(
             main_rfh()->GetRoutingID()),
         main_rfh());
   }
 
   void EmulateFailedNavigationAndExpectNoActivation(const GURL& url) {
     EXPECT_CALL(*client(), ToggleNotificationVisibility(false)).Times(1);
 
     // ReadyToCommitNavigation with browser-side navigation disabled is not

[engedy, 2017/03/02 10:38:10]

nit: Update this comment, suggestion:

// With browser-side navigation enabled, ReadyToCommitNavigation is invoked even
for failed navigations. This is correctly simulated by NavigationSimulator. Make
sure no activation message is sent in this case.

[clamy, 2017/03/02 13:11:17]

Done.

     // called in production code for failed navigations (e.g. network errors).
     // It is called with browser-side navigation enabled, in which case
     // RenderFrameHostTester already calls it, no need to call it manually.
-    content::RenderFrameHostTester* rfh_tester =
-        content::RenderFrameHostTester::For(main_rfh());
-    rfh_tester->SimulateNavigationStart(url);
-    rfh_tester->SimulateNavigationError(url, 403);
+    content::NavigationSimulator::NavigateAndFailFromDocument(
+        url, net::ERR_TIMED_OUT, main_rfh());
     ExpectActivationSignalForFrame(main_rfh(), false);
     ::testing::Mock::VerifyAndClearExpectations(client());
   }
 
   void EmulateInPageNavigation(
       const std::vector<bool>& blacklisted_urls,
       RedirectChainMatchPattern expected_pattern,
       ActivationDecision expected_activation_decision) {
     // This test examines the navigation with the following sequence of events:
     //   DidStartProvisional(main, "example.com")
     //   ReadyToCommitNavigation(“example.com”)
     //   DidCommitProvisional(main, "example.com")
     //   DidStartProvisional(sub, "example.com/login")
     //   DidCommitProvisional(sub, "example.com/login")
     //   DidCommitProvisional(main, "example.com#ref")
 
     NavigateAndExpectActivation(blacklisted_urls, {GURL(kExampleUrl)},
                                 expected_pattern, expected_activation_decision);
     EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);
-    content::RenderFrameHostTester::For(main_rfh())
-        ->SimulateNavigationCommit(GURL(kExampleUrl));
+    std::unique_ptr<content::NavigationSimulator> navigation_simulator =
+        content::NavigationSimulator::CreateRendererInitiated(GURL(kExampleUrl),
+                                                              main_rfh());
+    navigation_simulator->CommitSamePage();
     ExpectActivationSignalForFrame(main_rfh(), false);
     ::testing::Mock::VerifyAndClearExpectations(client());
   }
 
  private:
   static bool expected_measure_performance() {
     const double rate = GetPerformanceMeasurementRate();
     // Note: The case when 0 < rate < 1 is not deterministic, don't test it.
     EXPECT_TRUE(rate == 0 || rate == 1);
     return rate == 1;
@@ skipping 222 matching lines @@
       "" /* performance_measurement_rate */,
       "true" /* suppress_notifications */);
 
   NavigateAndExpectActivation({false}, {GURL(kExampleUrl)}, EMPTY,
                               ActivationDecision::ACTIVATED);
   EXPECT_CALL(*client(), ToggleNotificationVisibility(::testing::_)).Times(0);
   EmulateDidDisallowFirstSubresourceMessage();
 }
 
 TEST_F(ContentSubresourceFilterDriverFactoryTest, WhitelistSiteOnReload) {
-  // TODO(crbug.com/688393): enable this test for PlzNavigate once
-  // WCO::ReadyToCommitNavigation is invoked consistently for tests in
-  // PlzNavigate and non-PlzNavigate.
-  if (content::IsBrowserSideNavigationEnabled())
-    return;
-
   const struct {
     content::Referrer referrer;
     ui::PageTransition transition;
     ActivationDecision expected_activation_decision;
   } kTestCases[] = {
       {content::Referrer(), ui::PAGE_TRANSITION_LINK,
        ActivationDecision::ACTIVATED},
       {content::Referrer(GURL(kUrlA), blink::WebReferrerPolicyDefault),
        ui::PAGE_TRANSITION_LINK, ActivationDecision::ACTIVATED},
       {content::Referrer(GURL(kExampleUrl), blink::WebReferrerPolicyDefault),
@@ skipping 139 matching lines @@
     ActivationScopeTest,
     ContentSubresourceFilterDriverFactoryActivationScopeTest,
     ::testing::ValuesIn(kActivationScopeTestData));
 
 INSTANTIATE_TEST_CASE_P(
     ActivationLevelTest,
     ContentSubresourceFilterDriverFactoryActivationLevelTest,
     ::testing::ValuesIn(kActivationLevelTestData));
 
 }  // namespace subresource_filter