Enable websocket filtering via SubresourceFilter

components/subresource_filter/core/common/document_subresource_filter_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/core/common/document_subresource_filter.h"
 
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "components/subresource_filter/core/common/memory_mapped_ruleset.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 {
 
 namespace {
 
 constexpr auto kDisabled = ActivationLevel::DISABLED;
 constexpr auto kDryRun = ActivationLevel::DRYRUN;
 constexpr auto kEnabled = ActivationLevel::ENABLED;
 
 constexpr auto kImageType = proto::ELEMENT_TYPE_IMAGE;
 constexpr auto kSubdocumentType = proto::ELEMENT_TYPE_SUBDOCUMENT;
 
 constexpr const char kTestAlphaURL[] = "http://example.com/alpha";
 constexpr const char kTestAlphaDataURI[] = "data:text/plain,alpha";
+constexpr const char kTestAlphaWSURI[] = "ws://example.com/alpha";
 constexpr const char kTestBetaURL[] = "http://example.com/beta";
 
 constexpr const char kTestAlphaURLPathSuffix[] = "alpha";
 
 }  // namespace
 
 // Tests for DocumentSubresourceFilter class. ----------------------------------
 
 class DocumentSubresourceFilterTest : public ::testing::Test {
  public:
@@ skipping 25 matching lines @@
 
 TEST_F(DocumentSubresourceFilterTest, DryRun) {
   ActivationState activation_state(kDryRun);
   activation_state.measure_performance = true;
   DocumentSubresourceFilter filter(url::Origin(), activation_state, ruleset());
 
   EXPECT_EQ(LoadPolicy::WOULD_DISALLOW,
             filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType));
   EXPECT_EQ(LoadPolicy::ALLOW,
             filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType));
+  EXPECT_EQ(
+      LoadPolicy::WOULD_DISALLOW,
+      filter.GetLoadPolicy(GURL(kTestAlphaWSURI), proto::ELEMENT_TYPE_OTHER));
   EXPECT_EQ(LoadPolicy::ALLOW,
             filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType));
   EXPECT_EQ(LoadPolicy::WOULD_DISALLOW,
             filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType));
   EXPECT_EQ(LoadPolicy::ALLOW,
             filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType));
 
   const auto& statistics = filter.statistics();
-  EXPECT_EQ(5, statistics.num_loads_total);
-  EXPECT_EQ(4, statistics.num_loads_evaluated);
-  EXPECT_EQ(2, statistics.num_loads_matching_rules);
+  EXPECT_EQ(6, statistics.num_loads_total);
+  EXPECT_EQ(5, statistics.num_loads_evaluated);
+  EXPECT_EQ(3, statistics.num_loads_matching_rules);
   EXPECT_EQ(0, statistics.num_loads_disallowed);
 }
 
 TEST_F(DocumentSubresourceFilterTest, Enabled) {
   auto test_impl = [this](bool measure_performance) {
     ActivationState activation_state(kEnabled);
     activation_state.measure_performance = measure_performance;
     DocumentSubresourceFilter filter(url::Origin(), activation_state,
                                      ruleset());
 
     EXPECT_EQ(LoadPolicy::DISALLOW,
               filter.GetLoadPolicy(GURL(kTestAlphaURL), kImageType));
     EXPECT_EQ(LoadPolicy::ALLOW,
               filter.GetLoadPolicy(GURL(kTestAlphaDataURI), kImageType));
+    EXPECT_EQ(
+        LoadPolicy::DISALLOW,
+        filter.GetLoadPolicy(GURL(kTestAlphaWSURI), proto::ELEMENT_TYPE_OTHER));
     EXPECT_EQ(LoadPolicy::ALLOW,
               filter.GetLoadPolicy(GURL(kTestBetaURL), kImageType));
     EXPECT_EQ(LoadPolicy::DISALLOW,
               filter.GetLoadPolicy(GURL(kTestAlphaURL), kSubdocumentType));
     EXPECT_EQ(LoadPolicy::ALLOW,
               filter.GetLoadPolicy(GURL(kTestBetaURL), kSubdocumentType));
 
     const auto& statistics = filter.statistics();
-    EXPECT_EQ(5, statistics.num_loads_total);
-    EXPECT_EQ(4, statistics.num_loads_evaluated);
-    EXPECT_EQ(2, statistics.num_loads_matching_rules);
-    EXPECT_EQ(2, statistics.num_loads_disallowed);
+    EXPECT_EQ(6, statistics.num_loads_total);
+    EXPECT_EQ(5, statistics.num_loads_evaluated);
+    EXPECT_EQ(3, statistics.num_loads_matching_rules);
+    EXPECT_EQ(3, statistics.num_loads_disallowed);
 
     if (!measure_performance) {
       EXPECT_TRUE(statistics.evaluation_total_cpu_duration.is_zero());
       EXPECT_TRUE(statistics.evaluation_total_wall_duration.is_zero());
     }
     // Otherwise, don't expect |total_duration| to be non-zero, although it
     // practically is (when timer is supported).
   };
 
   test_impl(true /* measure_performance */);
@@ skipping 162 matching lines @@
     for (const auto& url_string : test_case.ancestor_document_urls)
       ancestor_document_urls.emplace_back(url_string);
 
     ActivationState activation_state = ComputeActivationState(
         test_case.activation_level, false, ancestor_document_urls, ruleset());
     EXPECT_EQ(test_case.expected_activation_state, activation_state);
   }
 }
 
 }  // namespace subresource_filter