Introduce SubframeNavigationFilteringThrottle

components/subresource_filter/content/browser/subframe_navigation_filtering_throttle_unittest.cc

+// Copyright 2017 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/subframe_navigation_filtering_throttle.h"
+
+#include <memory>
+
+#include "base/callback_forward.h"
+#include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/test_simple_task_runner.h"
+#include "components/subresource_filter/content/browser/async_document_subresource_filter.h"
+#include "components/subresource_filter/core/common/activation_level.h"
+#include "components/subresource_filter/core/common/activation_state.h"
+#include "components/subresource_filter/core/common/proto/rules.pb.h"
+#include "components/subresource_filter/core/common/test_ruleset_creator.h"
+#include "components/subresource_filter/core/common/test_ruleset_utils.h"
+#include "content/public/browser/navigation_handle.h"
+#include "content/public/common/referrer.h"
+#include "content/public/test/test_renderer_host.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace subresource_filter {
+
+namespace {
+
+static void UpdateThrottleCheckResult(
+    content::NavigationThrottle::ThrottleCheckResult* to_update,
+    content::NavigationThrottle::ThrottleCheckResult result) {
+  *to_update = result;
+}
+
+}  // namespace
+
+class SubframeNavigationFilteringThrottleTest
+    : public content::RenderViewHostTestHarness {
+ public:
+  SubframeNavigationFilteringThrottleTest()
+      : blocking_task_runner_(new base::TestSimpleTaskRunner) {}
+  ~SubframeNavigationFilteringThrottleTest() override {}
+
+  void SetUp() override {
+    content::RenderViewHostTestHarness::SetUp();
+    NavigateAndCommit(GURL("https://example.test"));
+  }
+
+  void TearDown() override {
+    test_handle_.reset();
+    dealer_handle_.reset();
+    ruleset_handle_.reset();
+    async_filter_.reset();
+    RunUntilIdle();
+    content::RenderViewHostTestHarness::TearDown();
+  }
+
+  void InitializeDocumentSubresourceFilter(const GURL& document_url) {
+    ASSERT_NO_FATAL_FAILURE(
+        test_ruleset_creator_.CreateRulesetToDisallowURLsWithPathSuffix(
+            "disallowed.html", &test_ruleset_pair_));
+    dealer_handle_ =
+        base::MakeUnique<VerifiedRulesetDealer::Handle>(blocking_task_runner_);
+    dealer_handle_->SetRulesetFile(
+        testing::TestRuleset::Open(test_ruleset_pair_.indexed));
+    ruleset_handle_ =
+        base::MakeUnique<VerifiedRuleset::Handle>(dealer_handle_.get());
+    // Unretained is safe because the test blocks waiting until the task is
+    // run.
+    async_filter_ = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+        ruleset_handle_.get(),
+        AsyncDocumentSubresourceFilter::InitializationParams(
+            document_url, ActivationLevel::ENABLED,
+            false /* measure_performance */),
+        base::Bind(&SubframeNavigationFilteringThrottleTest::ExpectActivation,
+                   base::Unretained(this),
+                   ActivationState(ActivationLevel::ENABLED)),
+        base::OnceClosure());
+    RunUntilIdle();
+  }
+
+  void ExpectActivation(ActivationState expected, ActivationState state) {
+    EXPECT_EQ(expected.activation_level, state.activation_level);
+  }
+
+  void RunUntilIdle() {
+    blocking_task_runner_->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void CreateTestSubframeNavigation(const GURL& first_url,
+                                    content::RenderFrameHost* parent) {
+    navigating_subframe_ =
+        content::RenderFrameHostTester::For(parent)->AppendChild(
+            base::StringPrintf("subframe-%s", first_url.spec().c_str()));
+    test_handle_ = content::NavigationHandle::CreateNavigationHandleForTesting(
+        first_url, navigating_subframe_);
+    test_handle_->RegisterThrottleForTesting(
+        base::MakeUnique<SubframeNavigationFilteringThrottle>(
+            test_handle_.get(), async_filter_.get()));
+  }
+
+  // Calls WillStartRequest and runs the run loop until the throttle has
+  // finished checking.
+  void SimulateWillStartAndExpectAsyncResult(
+      content::NavigationThrottle::ThrottleCheckResult expected_result) {
+    auto async_result = content::NavigationThrottle::DEFER;
+    auto sync_result = test_handle_->CallWillStartRequestForTesting(
+        false /* is_post */, content::Referrer(), true /* has_user_gesture */,
+        ui::PageTransition::PAGE_TRANSITION_LINK,
+        false /* is_external_protocol */,
+        base::Bind(&UpdateThrottleCheckResult, &async_result));
+    EXPECT_EQ(content::NavigationThrottle::DEFER, sync_result);
+    RunUntilIdle();
+    EXPECT_EQ(expected_result, async_result);
+  }
+
+  // Calls WillRedirectRequest  and runs the run loop until the throttle has
+  // finished checking.
+  void SimulateWillRedirectAndExpectAsyncResult(
+      const GURL& new_url,
+      content::NavigationThrottle::ThrottleCheckResult expected_result) {
+    auto async_result = content::NavigationThrottle::DEFER;
+    auto sync_result = test_handle_->CallWillRedirectRequestForTesting(
+        new_url, false /* new_method_is_post */, GURL(),
+        false /* new_is_external_protocol */,
+        base::Bind(&UpdateThrottleCheckResult, &async_result));
+    EXPECT_EQ(content::NavigationThrottle::DEFER, sync_result);
+    RunUntilIdle();
+    EXPECT_EQ(expected_result, async_result);
+  }
+
+  void SimulateWillProcessResponseAndExpectResult(
+      content::NavigationThrottle::ThrottleCheckResult expected_result) {
+    EXPECT_EQ(expected_result,
+              test_handle_->CallWillProcessResponseForTesting(
+                  navigating_subframe_, "",
+                  content::NavigationHandle::ThrottleChecksFinishedCallback()));
+  }
+
+ private:
+  scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_;
+
+  testing::TestRulesetCreator test_ruleset_creator_;
+  testing::TestRulesetPair test_ruleset_pair_;
+
+  std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;
+  std::unique_ptr<VerifiedRuleset::Handle> ruleset_handle_;
+
+  std::unique_ptr<AsyncDocumentSubresourceFilter> async_filter_;
+
+  std::unique_ptr<content::NavigationHandle> test_handle_;
+
+  content::RenderFrameHost* navigating_subframe_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(SubframeNavigationFilteringThrottleTest);
+};
+
+TEST_F(SubframeNavigationFilteringThrottleTest, FilterOnStart) {
+  InitializeDocumentSubresourceFilter(GURL("https://example.test"));
+  CreateTestSubframeNavigation(GURL("https://example.test/disallowed.html"),
+                               main_rfh());
+  SimulateWillStartAndExpectAsyncResult(content::NavigationThrottle::CANCEL);
+}
+
+TEST_F(SubframeNavigationFilteringThrottleTest, FilterOnRedirect) {
+  InitializeDocumentSubresourceFilter(GURL("https://example.test"));
+  CreateTestSubframeNavigation(GURL("https://example.test/allowed.html"),
+                               main_rfh());
+
+  SimulateWillStartAndExpectAsyncResult(content::NavigationThrottle::PROCEED);
+  SimulateWillRedirectAndExpectAsyncResult(
+      GURL("https://example.test/disallowed.html"),
+      content::NavigationThrottle::CANCEL);
+}
+
+TEST_F(SubframeNavigationFilteringThrottleTest, FilterOnSecondRedirect) {
+  InitializeDocumentSubresourceFilter(GURL("https://example.test"));
+  CreateTestSubframeNavigation(GURL("https://example.test/allowed.html"),
+                               main_rfh());
+
+  SimulateWillStartAndExpectAsyncResult(content::NavigationThrottle::PROCEED);
+  SimulateWillRedirectAndExpectAsyncResult(
+      GURL("https://example.test/allowed2.html"),
+      content::NavigationThrottle::PROCEED);
+  SimulateWillRedirectAndExpectAsyncResult(
+      GURL("https://example.test/disallowed.html"),
+      content::NavigationThrottle::CANCEL);
+}
+
+TEST_F(SubframeNavigationFilteringThrottleTest, NeverFilterNonMatchingRule) {
+  InitializeDocumentSubresourceFilter(GURL("https://example.test"));
+  CreateTestSubframeNavigation(GURL("https://example.test/allowed.html"),
+                               main_rfh());
+
+  SimulateWillStartAndExpectAsyncResult(content::NavigationThrottle::PROCEED);
+  SimulateWillRedirectAndExpectAsyncResult(
+      GURL("https://example.test/allowed2.html"),
+      content::NavigationThrottle::PROCEED);
+  SimulateWillProcessResponseAndExpectResult(
+      content::NavigationThrottle::PROCEED);
+}
+
+TEST_F(SubframeNavigationFilteringThrottleTest, FilterSubsubframe) {
+  // Fake an activation of the subframe.
+  content::RenderFrameHost* parent_subframe =
+      content::RenderFrameHostTester::For(main_rfh())
+          ->AppendChild("parent-sub");
+  GURL test_url = GURL("https://example.test");
+  content::RenderFrameHostTester::For(parent_subframe)
+      ->SimulateNavigationStart(test_url);
+  InitializeDocumentSubresourceFilter(GURL("https://example.test"));
+  content::RenderFrameHostTester::For(parent_subframe)
+      ->SimulateNavigationCommit(test_url);
+
+  CreateTestSubframeNavigation(GURL("https://example.test/disallowed.html"),
+                               parent_subframe);
+  SimulateWillStartAndExpectAsyncResult(content::NavigationThrottle::CANCEL);
+}
+
+}  // namespace subresource_filter