ActivationStateComputingThrottle unit tests

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"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
+#include "components/subresource_filter/content/browser/async_document_subresource_filter_test_utils.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() = default;
@@ skipping 49 matching lines @@
   scoped_refptr<base::TestSimpleTaskRunner> blocking_task_runner_ =
       new base::TestSimpleTaskRunner;
 
   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);
-};
-
+// TODO(csharrison): If more consumers need to test these callbacks at this
+// granularity, consider moving these classes into
+// async_document_subresource_filter_test_utils.
 class TestCallbackReceiver {
  public:
   TestCallbackReceiver() = default;
 
-  base::Closure closure() {
+  base::Closure GetClosure() {
     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() {
+  AsyncDocumentSubresourceFilter::LoadPolicyCallback GetCallback() {
     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;
+  testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
       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;
+  testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
       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;
+  testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
       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;
+  testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.callback(),
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
       base::OnceClosure());
 
   LoadPolicyCallbackReceiver load_policy_1;
   LoadPolicyCallbackReceiver load_policy_2;
   filter->GetLoadPolicyForSubdocument(GURL("http://example.com/allowed.html"),
-                                      load_policy_1.callback());
+                                      load_policy_1.GetCallback());
   filter->GetLoadPolicyForSubdocument(
-      GURL("http://example.com/disallowed.html"), load_policy_2.callback());
+      GURL("http://example.com/disallowed.html"), load_policy_2.GetCallback());
 
   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;
+  testing::TestActivationStateCallbackReceiver activation_state;
   auto filter = base::MakeUnique<AsyncDocumentSubresourceFilter>(
-      ruleset_handle.get(), std::move(params), activation_state.callback(),
-      first_disallowed_load_receiver.closure());
+      ruleset_handle.get(), std::move(params), activation_state.GetCallback(),
+      first_disallowed_load_receiver.GetClosure());
 
   LoadPolicyCallbackReceiver load_policy_1;
   filter->GetLoadPolicyForSubdocument(GURL("http://example.com/allowed.html"),
-                                      load_policy_1.callback());
+                                      load_policy_1.GetCallback());
   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());
+      GURL("http://example.com/disallowed.html"), load_policy_2.GetCallback());
   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