Introduce AsyncDocumentSubresourceFilter.

components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc

Index: components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc
diff --git a/components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc b/components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a3cef1565cd9923fc7aa080645a7285b6967252f
--- /dev/null
+++ b/components/subresource_filter/content/browser/async_document_subresource_filter_unittest.cc
@@ -0,0 +1,267 @@
+// 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 <memory>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/macros.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()
+      : reply_task_runner_(new base::TestSimpleTaskRunner),
+        reply_task_runner_handle_(reply_task_runner_),
+        blocking_task_runner_(new base::TestSimpleTaskRunner) {}
+
+ protected:
+  void SetUp() override {
+    std::vector<proto::UrlRule> rules;
+    rules.push_back(testing::CreateWhitelistRuleForDocument(
+        "whitelisted.subframe.com", proto::ACTIVATION_TYPE_GENERICBLOCK,
+        {"example.com"}));
+    rules.push_back(testing::CreateSuffixRule("disallowed.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 base::MakeUnique<VerifiedRuleset::Handle>(dealer_handle());
+  }
+
+ private:
+  testing::TestRulesetCreator test_ruleset_creator_;
+  testing::TestRulesetPair test_ruleset_pair_;
+
+  // Note: ADSF assumes a task runner is associated with the current thread.
+  scoped_refptr<base::TestSimpleTaskRunner> reply_task_runner_;
+  base::SequencedTaskRunnerHandle reply_task_runner_handle_;
+  scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_;
+
+  std::unique_ptr<VerifiedRulesetDealer::Handle> dealer_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsyncDocumentSubresourceFilterTest);
+};
+
+namespace {
+
+class TestActivationStateCallbackReceiver {
+ public:
+  TestActivationStateCallbackReceiver() = default;
+
+  base::Callback<void(ActivationState)> callback() {
+    return base::Bind(&TestActivationStateCallbackReceiver::Callback,
+                      base::Unretained(this));
+  }
+  void ExpectReceivedOnce(ActivationState expected_state) const {
+    ASSERT_EQ(1, callback_count_);
+    EXPECT_EQ(expected_state, last_activation_state_);
+  }
+
+ private:
+  void Callback(ActivationState activation_state) {
+    ++callback_count_;
+    last_activation_state_ = activation_state;
+  }
+
+  ActivationState last_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 ExpectReceivedOnce(LoadPolicy load_policy) const {
+    ASSERT_EQ(1, callback_count_);
+    EXPECT_EQ(load_policy, last_load_policy_);
+  }
+
+ private:
+  void Callback(LoadPolicy load_policy) {
+    ++callback_count_;
+    last_load_policy_ = load_policy;
+  }
+
+  int callback_count_ = 0;
+  LoadPolicy last_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.ExpectReceivedOnce(
+      ActivationState(ActivationLevel::ENABLED));
+}
+
+TEST_F(AsyncDocumentSubresourceFilterTest, ActivationStateIsComputedCorrectly) {
+  dealer_handle()->SetRulesetFile(testing::TestRuleset::Open(ruleset()));
+  auto ruleset_handle = CreateRulesetHandle();
+
+  AsyncDocumentSubresourceFilter::InitializationParams params(
+      GURL("http://whitelisted.subframe.com"), ActivationLevel::ENABLED, false);
+  params.parent_document_origin = url::Origin(GURL("http://example.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.ExpectReceivedOnce(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.ExpectReceivedOnce(
+      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/allowed.html"),
+                                      load_policy_1.callback());
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/disallowed.html"), load_policy_2.callback());
+
+  RunUntilIdle();
+  load_policy_1.ExpectReceivedOnce(LoadPolicy::ALLOW);
+  load_policy_2.ExpectReceivedOnce(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/allowed.html"),
+                                      load_policy_1.callback());
+  RunUntilIdle();
+  load_policy_1.ExpectReceivedOnce(LoadPolicy::ALLOW);
+  EXPECT_EQ(0, first_disallowed_load_receiver.callback_count());
+
+  LoadPolicyCallbackReceiver load_policy_2;
+  filter->GetLoadPolicyForSubdocument(
+      GURL("http://example.com/disallowed.html"), load_policy_2.callback());
+  RunUntilIdle();
+  load_policy_2.ExpectReceivedOnce(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