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 <memory>
+#include <vector>
+
+#include "base/bind.h"

[engedy, 2017/02/14 15:13:14]

nit: #include "base/bind_helpers.h"

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+#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()
+      : 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,

[engedy, 2017/02/14 15:13:14]

nit: How about whilelisted.subframe.com and example.com for readability?

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+        {"parent1.com", "parent2.com"}));
+    rules.push_back(testing::CreateSuffixRule("block-this.html"));

[engedy, 2017/02/14 15:13:14]

nit: disallowed.html

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+
+    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>(

[engedy, 2017/02/14 15:13:14]

nit: Can we use MakeUnique for this?

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+        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_;

[engedy, 2017/02/14 15:13:14]

nit: Can there be any tasks left in these task runners that hold file handles to
test rulesets? If so, we should move line 76 and 77 to the first place, so that
the task runners are pumped out, all potential file handles are closed, and temp
directories can be cleaned up.

[pkalinnikov, 2017/02/14 18:47:14]

We have RunUntilIdle() in TearDown(), but still let's do this permutation to be
on the safe side.

+  testing::TestRulesetPair test_ruleset_pair_;
+
+  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 Expect(ActivationState expected_state) const {

[engedy, 2017/02/14 15:13:14]

nit: How about making the expectations in the tests more specific by naming this
ExpectReceivedOnce? Same below.

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+    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_;

[engedy, 2017/02/14 15:13:14]

nit: last_activation_state_;

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+  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_;

[engedy, 2017/02/14 15:13:14]

nit: last_load_policy_;

[pkalinnikov, 2017/02/14 18:47:14]

Done.

+
+  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