Introduce AsyncDocumentSubresourceFilter.

components/subresource_filter/content/browser/async_document_subresource_filter_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/async_document_subresource_filter.h"
+
+#include <vector>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.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 "testing/gtest/include/gtest/gtest.h"
+
+namespace subresource_filter {
+
+class AsyncDocumentSubresourceFilterTest : public ::testing::Test {
+ public:
+  AsyncDocumentSubresourceFilterTest()
+      : blocking_task_runner_(new base::TestSimpleTaskRunner),
+        reply_task_runner_(new base::TestSimpleTaskRunner),
+        reply_task_runner_handle_(reply_task_runner_) {}
+
+ protected:
+  void SetUp() override {
+    std::vector<proto::UrlRule> rules;
+    rules.push_back(testing::CreateWhitelistRuleForDocument(
+        "child2.com", proto::ACTIVATION_TYPE_GENERICBLOCK,
+        {"parent1.com", "parent2.com"}));
+    rules.push_back(testing::CreateSuffixRule("block-this.html"));
+
+    ASSERT_NO_FATAL_FAILURE(test_ruleset_creator_.CreateRulesetWithRules(
+        rules, &test_ruleset_pair_));
+
+    dealer_handle_.reset(
+        new VerifiedRulesetDealer::Handle(blocking_task_runner_));
+  }
+
+  void TearDown() override {
+    dealer_handle_.reset(nullptr);
+    RunUntilIdle();
+  }
+
+  const testing::TestRuleset& ruleset() const {
+    return test_ruleset_pair_.indexed;
+  }
+
+  void RunUntilIdle() {
+    while (blocking_task_runner_->HasPendingTask() ||
+           reply_task_runner_->HasPendingTask()) {
+      blocking_task_runner_->RunUntilIdle();
+      reply_task_runner_->RunUntilIdle();
+    }
+  }
+
+  VerifiedRulesetDealer::Handle* dealer_handle() {
+    return dealer_handle_.get();
+  }
+
+  std::unique_ptr<VerifiedRuleset::Handle> CreateRulesetHandle() {
+    return std::unique_ptr<VerifiedRuleset::Handle>(
+        new VerifiedRuleset::Handle(dealer_handle()));
+  }
+
+ private:
+  scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_;
+  scoped_refptr<base::TestSimpleTaskRunner> reply_task_runner_;
+  // Note: ADSF assumes a task runner is associated with the current thread.
+  base::SequencedTaskRunnerHandle reply_task_runner_handle_;
+
+  testing::TestRulesetCreator test_ruleset_creator_;
+  testing::TestRulesetPair test_ruleset_pair_;
+
+  std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;

[Charlie Harrison, 2017/02/13 20:07:50]

#include <memory>

[pkalinnikov, 2017/02/14 09:31:07]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilterTest);

[Charlie Harrison, 2017/02/13 20:07:50]

#include "base/macros.h"

[pkalinnikov, 2017/02/14 09:31:07]

Done.

+};
+
+namespace {
+
+class TestActivationStateCallbackReceiver {
+ public:
+  TestActivationStateCallbackReceiver() = default;
+
+  base::Callback<void(ActivationState)> callback() {
+    return base::Bind(&TestActivationStateCallbackReceiver::Callback,
+                      base::Unretained(this));
+  }
+  void Expect(ActivationState expected_state) const {
+    ASSERT_EQ(1, callback_count_);
+    EXPECT_EQ(expected_state, activation_state_);
+  }
+
+ private:
+  void Callback(ActivationState activation_state) {
+    ++callback_count_;
+    activation_state_ = activation_state;
+  }
+
+  ActivationState activation_state_;
+  int callback_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestActivationStateCallbackReceiver);
+};
+
+class TestCallbackReceiver {
+ public:
+  TestCallbackReceiver() = default;
+
+  base::Closure closure() {
+    return base::Bind(&TestCallbackReceiver::Callback, base::Unretained(this));
+  }
+  int callback_count() const { return callback_count_; }
+
+ private:
+  void Callback() { ++callback_count_; }
+
+  int callback_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCallbackReceiver);
+};
+
+class LoadPolicyCallbackReceiver {
+ public:
+  LoadPolicyCallbackReceiver() = default;
+
+  AsyncDocumentSubresourceFilter::LoadPolicyCallback callback() {
+    return base::Bind(&LoadPolicyCallbackReceiver::Callback,
+                      base::Unretained(this));
+  }
+  void Expect(AsyncDocumentSubresourceFilter::LoadPolicy load_policy) const {
+    ASSERT_EQ(1, callback_count_);
+    EXPECT_EQ(load_policy, load_policy_);
+  }
+
+ private:
+  void Callback(AsyncDocumentSubresourceFilter::LoadPolicy load_policy) {
+    ++callback_count_;
+    load_policy_ = load_policy;
+  }
+
+  int callback_count_ = 0;
+  AsyncDocumentSubresourceFilter::LoadPolicy load_policy_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoadPolicyCallbackReceiver);
+};
+
+}  // namespace
+
+TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsReported) {
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+  auto ruleset_handle = CreateRulesetHandle();
+
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://example.com"), ActivationLevel::ENABLED, false);
+
+  TestActivationStateCallbackReceiver activation_state;
+  auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      base::OnceClosure());
+
+  RunUntilIdle();
+  activation_state.Expect(ActivationState(ActivationLevel::ENABLED));
+}
+
+TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsComputedCorrectly) {
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+  auto ruleset_handle = CreateRulesetHandle();
+
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://child2.com"), ActivationLevel::ENABLED, false);
+  params.parent_document_origin = url::Origin(GURL("http://parent2.com"));
+
+  TestActivationStateCallbackReceiver activation_state;
+  auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      base::OnceClosure());
+
+  RunUntilIdle();
+
+  ActivationState expected_activation_state(ActivationLevel::ENABLED);
+  expected_activation_state.generic_blocking_rules_disabled = true;
+  activation_state.Expect(expected_activation_state);
+}
+
+TEST_F(AsyncDocumentSubresourceFilterTest, DisabledForCorruptRuleset) {
+  testing::TestRuleset::CorruptByFilling(ruleset(), 0, 100, 0xFF);
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+
+  auto ruleset_handle = CreateRulesetHandle();
+
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://example.com"), ActivationLevel::ENABLED, false);
+
+  TestActivationStateCallbackReceiver activation_state;
+  auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      base::OnceClosure());
+
+  RunUntilIdle();
+  activation_state.Expect(ActivationState(ActivationLevel::DISABLED));
+}
+
+TEST_F(AsyncDocumentSubresourceFilterTest, GetLoadPolicyForSubdocument) {
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+  auto ruleset_handle = CreateRulesetHandle();
+
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://example.com"), ActivationLevel::ENABLED, false);
+
+  TestActivationStateCallbackReceiver activation_state;
+  auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      base::OnceClosure());
+
+  LoadPolicyCallbackReceiver load_policy_1;
+  LoadPolicyCallbackReceiver load_policy_2;
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/allow-this.html"), load_policy_1.callback());
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/block-this.html"), load_policy_2.callback());
+
+  RunUntilIdle();
+  load_policy_1.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Allow);
+  load_policy_2.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Disallow);
+}
+
+TEST_F(AsyncDocumentSubresourceFilterTest, FirstDisallowedLoadIsReported) {
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+  auto ruleset_handle = CreateRulesetHandle();
+
+  TestCallbackReceiver first_disallowed_load_receiver;
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://example.com"), ActivationLevel::ENABLED, false);
+
+  TestActivationStateCallbackReceiver activation_state;
+  auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
+      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      first_disallowed_load_receiver.closure());
+
+  LoadPolicyCallbackReceiver load_policy_1;
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/allow-this.html"), load_policy_1.callback());
+  RunUntilIdle();
+  load_policy_1.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Allow);
+  EXPECT_EQ(0, first_disallowed_load_receiver.callback_count());
+
+  LoadPolicyCallbackReceiver load_policy_2;
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/block-this.html"), load_policy_2.callback());
+  RunUntilIdle();
+  load_policy_2.Expect(AsyncDocumentSubresourceFilter::LoadPolicy::Disallow);
+  EXPECT_EQ(0, first_disallowed_load_receiver.callback_count());
+
+  filter->ReportDisallowedLoad();
+  EXPECT_EQ(1, first_disallowed_load_receiver.callback_count());
+  RunUntilIdle();
+}
+
+}  // namespace subresource_filter