Introduce AsyncDocumentSubresourceFilter.

components/subresource_filter/content/renderer/subresource_filter_agent_unittest.cc

 // Copyright 2016 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/renderer/subresource_filter_agent.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/subresource_filter/content/common/document_load_statistics.h"
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
 #include "components/subresource_filter/content/renderer/unverified_ruleset_dealer.h"
 #include "components/subresource_filter/core/common/scoped_timers.h"
 #include "components/subresource_filter/core/common/test_ruleset_creator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebDocumentSubresourceFilter.h"
+#include "third_party/WebKit/public/platform/WebDocumentSubresourceFilterLoadPolicy.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "url/gurl.h"
 
 namespace subresource_filter {
 
 namespace {
 
 // The SubresourceFilterAgent with its dependencies on Blink mocked out.
 //
@@ skipping 132 matching lines @@
     EXPECT_CALL(*agent(), SignalFirstSubresourceDisallowedForCommittedLoad())
         .Times(0);
   }
 
   void ExpectDocumentLoadStatisticsSent() {
     EXPECT_CALL(*agent(), SendDocumentLoadStatistics(::testing::_));
   }
 
   void ExpectLoadPolicy(
       base::StringPiece url_spec,
-      blink::WebDocumentSubresourceFilter::LoadPolicy expected_policy) {
+      blink::WebDocumentSubresourceFilterLoadPolicy expected_policy) {
     blink::WebURL url = GURL(url_spec);
     blink::WebURLRequest::RequestContext request_context =
         blink::WebURLRequest::RequestContextImage;
-    blink::WebDocumentSubresourceFilter::LoadPolicy actual_policy =
+    blink::WebDocumentSubresourceFilterLoadPolicy actual_policy =
         agent()->filter()->getLoadPolicy(url, request_context);
     EXPECT_EQ(expected_policy, actual_policy);
 
     // If the load policy indicated the load was filtered, simulate a filtered
     // load callback. In production, this will be called in FrameFetchContext,
     // but we simulate the call here.
-    if (actual_policy == blink::WebDocumentSubresourceFilter::Disallow)
+    if (actual_policy ==
+        blink::WebDocumentSubresourceFilterLoadPolicy::Disallow)
       agent()->filter()->reportDisallowedLoad();
   }
 
   SubresourceFilterAgentUnderTest* agent() { return agent_.get(); }
   content::RenderFrameObserver* agent_as_rfo() {
     return static_cast<content::RenderFrameObserver*>(agent_.get());
   }
 
  private:
   testing::TestRulesetCreator test_ruleset_creator_;
@@ skipping 80 matching lines @@
   base::HistogramTester histogram_tester;
   ASSERT_NO_FATAL_FAILURE(
       SetTestRulesetToDisallowURLsWithPathSuffix(kTestFirstURLPathSuffix));
 
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   ExpectSignalAboutFirstSubresourceDisallowed();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 
   // In-page navigation should not count as a new load.
   ExpectNoSubresourceFilterGetsInjected();
   ExpectNoSignalAboutFirstSubresourceDisallowed();
   PerformSamePageNavigationWithoutSettingActivationLevel();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
 
   ExpectNoSubresourceFilterGetsInjected();
   StartLoadWithoutSettingActivationLevel();
   FinishLoad();
 
   // Resource loads after the in-page navigation should not be counted toward
   // the figures below, as they came after the original page load event.
   histogram_tester.ExpectUniqueSample(kSubresourcesTotal, 2, 1);
   histogram_tester.ExpectUniqueSample(kSubresourcesEvaluated, 2, 1);
   histogram_tester.ExpectUniqueSample(kSubresourcesMatchedRules, 1, 1);
@@ skipping 10 matching lines @@
     base::HistogramTester histogram_tester;
     ASSERT_NO_FATAL_FAILURE(
         SetTestRulesetToDisallowURLsWithPathSuffix(kTestFirstURLPathSuffix));
     ExpectSubresourceFilterGetsInjected();
     StartLoadAndSetActivationLevel(ActivationLevel::ENABLED,
                                    measure_performance);
     ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
     ExpectSignalAboutFirstSubresourceDisallowed();
     ExpectLoadPolicy(kTestFirstURL,
-                     blink::WebDocumentSubresourceFilter::Disallow);
+                     blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
     ExpectNoSignalAboutFirstSubresourceDisallowed();
     ExpectLoadPolicy(kTestFirstURL,
-                     blink::WebDocumentSubresourceFilter::Disallow);
+                     blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
     ExpectNoSignalAboutFirstSubresourceDisallowed();
     ExpectLoadPolicy(kTestSecondURL,
-                     blink::WebDocumentSubresourceFilter::Allow);
+                     blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
     ExpectDocumentLoadStatisticsSent();
     FinishLoad();
 
     ExpectSubresourceFilterGetsInjected();
     StartLoadAndSetActivationLevel(ActivationLevel::ENABLED,
                                    measure_performance);
     ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
     ExpectNoSignalAboutFirstSubresourceDisallowed();
     ExpectLoadPolicy(kTestSecondURL,
-                     blink::WebDocumentSubresourceFilter::Allow);
+                     blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
     ExpectSignalAboutFirstSubresourceDisallowed();
     ExpectLoadPolicy(kTestFirstURL,
-                     blink::WebDocumentSubresourceFilter::Disallow);
+                     blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
     ExpectDocumentLoadStatisticsSent();
     FinishLoad();
 
     histogram_tester.ExpectUniqueSample(
         kDocumentLoadActivationLevel,
         static_cast<int>(ActivationLevel::ENABLED), 2);
     histogram_tester.ExpectUniqueSample(kDocumentLoadRulesetIsAvailable, 1, 2);
 
     EXPECT_THAT(histogram_tester.GetAllSamples(kSubresourcesTotal),
                 ::testing::ElementsAre(base::Bucket(2, 1), base::Bucket(3, 1)));
@@ skipping 20 matching lines @@
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   // Set the new ruleset just after the deadline for being used for the current
   // load, to exercises doing filtering based on obseleted rulesets.
   ASSERT_NO_FATAL_FAILURE(
       SetTestRulesetToDisallowURLsWithPathSuffix(kTestSecondURLPathSuffix));
 
   ExpectSignalAboutFirstSubresourceDisallowed();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   ExpectSignalAboutFirstSubresourceDisallowed();
-  ExpectLoadPolicy(kTestFirstURL, blink::WebDocumentSubresourceFilter::Allow);
+  ExpectLoadPolicy(kTestFirstURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectLoadPolicy(kTestSecondURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 }
 
 // If a provisional load is aborted, the RenderFrameObservers might not receive
 // any further notifications about that load. It is thus possible that there
 // will be two RenderFrameObserver::DidStartProvisionalLoad in a row. Make sure
 // that the activation decision does not outlive the first provisional load.
 TEST_F(SubresourceFilterAgentTest,
        Enabled_FilteringNoLongerEffectAfterProvisionalLoadIsCancelled) {
@@ skipping 14 matching lines @@
   base::HistogramTester histogram_tester;
   ASSERT_NO_FATAL_FAILURE(
       SetTestRulesetToDisallowURLsWithPathSuffix(kTestFirstURLPathSuffix));
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::DRYRUN);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   // In dry-run mode, loads to the first URL should be recorded as
   // `MatchedRules`, but still be allowed to proceed and not recorded as
   // `Disallowed`.
-  ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::WouldDisallow);
-  ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::WouldDisallow);
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+  ExpectLoadPolicy(
+      kTestFirstURL,
+      blink::WebDocumentSubresourceFilterLoadPolicy::WouldDisallow);
+  ExpectLoadPolicy(
+      kTestFirstURL,
+      blink::WebDocumentSubresourceFilterLoadPolicy::WouldDisallow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 
   histogram_tester.ExpectUniqueSample(kDocumentLoadActivationLevel,
                                       static_cast<int>(ActivationLevel::DRYRUN),
                                       1);
   histogram_tester.ExpectUniqueSample(kDocumentLoadRulesetIsAvailable, 1, 1);
 
   histogram_tester.ExpectUniqueSample(kSubresourcesTotal, 3, 1);
   histogram_tester.ExpectUniqueSample(kSubresourcesEvaluated, 3, 1);
   histogram_tester.ExpectUniqueSample(kSubresourcesMatchedRules, 2, 1);
   histogram_tester.ExpectUniqueSample(kSubresourcesDisallowed, 0, 1);
 
   // Performance measurement is switched off.
   histogram_tester.ExpectTotalCount(kEvaluationTotalWallDuration, 0);
   histogram_tester.ExpectTotalCount(kEvaluationTotalCPUDuration, 0);
 }
 
 TEST_F(SubresourceFilterAgentTest,
        SignalFirstSubresourceDisallowed_OncePerDocumentLoad) {
   ASSERT_NO_FATAL_FAILURE(
       SetTestRulesetToDisallowURLsWithPathSuffix(kTestFirstURLPathSuffix));
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   ExpectSignalAboutFirstSubresourceDisallowed();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
   ExpectNoSignalAboutFirstSubresourceDisallowed();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
-  ExpectLoadPolicy(kTestSecondURL, blink::WebDocumentSubresourceFilter::Allow);
+  ExpectLoadPolicy(kTestSecondURL,
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Allow);
   ExpectSignalAboutFirstSubresourceDisallowed();
   ExpectLoadPolicy(kTestFirstURL,
-                   blink::WebDocumentSubresourceFilter::Disallow);
+                   blink::WebDocumentSubresourceFilterLoadPolicy::Disallow);
   ExpectDocumentLoadStatisticsSent();
   FinishLoad();
 }
 
 TEST_F(SubresourceFilterAgentTest,
        SignalFirstSubresourceDisallowed_ComesAfterAgentDestroyed) {
   ASSERT_NO_FATAL_FAILURE(
       SetTestRulesetToDisallowURLsWithPathSuffix(kTestFirstURLPathSuffix));
   ExpectSubresourceFilterGetsInjected();
   StartLoadAndSetActivationLevel(ActivationLevel::ENABLED);
   ASSERT_TRUE(::testing::Mock::VerifyAndClearExpectations(agent()));
 
   auto filter = agent()->TakeFilter();
   ResetAgent();
 
   // The filter has been disconnected from the agent, so a call to
   // reportDisallowedLoad() should not signal a first resource disallowed call
   // to the agent, nor should it cause a crash.
   ExpectNoSignalAboutFirstSubresourceDisallowed();
 
   filter->reportDisallowedLoad();
 }
 
 }  // namespace subresource_filter