[fuchsia] Add wildcard support for hosts filtering.

Add wildcard-based filtering for hosts in UrlRequestRewriteRules.

Bug: 1011156

Change-Id: I982b2241e622194dbf39ccd8519af8f92ee593c9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1838706
Commit-Queue: Fabrice de Gans-Riberi <fdegans@chromium.org>
Reviewed-by: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704406}

fuchsia/engine/BUILD.gn

@@ -269,6 +269,7 @@ test("web_engine_unittests") {
     "browser/cookie_manager_impl_unittest.cc",
     "browser/frame_impl_unittest.cc",
     "browser/url_request_rewrite_rules_manager_unittest.cc",
+    "common/web_engine_url_loader_throttle_unittest.cc",
     "context_provider_impl_unittest.cc",
     "fake_context.cc",
     "fake_context.h",

fuchsia/engine/common/web_engine_url_loader_throttle.cc

@@ -91,17 +91,35 @@ void ApplyRewrite(network::ResourceRequest* request,
   }
 }
 
+bool HostMatches(const base::StringPiece& url_host,
+                 const base::StringPiece& rule_host) {
+  const base::StringPiece kWildcard("*.");
+  if (base::StartsWith(rule_host, kWildcard, base::CompareCase::SENSITIVE)) {
+    // |rule_host| starts with a wildcard (e.g. "*.test.xyz"). Check if
+    // |url_host| ends with ".test.xyz". The "." character is included here to
+    // prevent accidentally matching "notatest.xyz".
+    if (base::EndsWith(url_host, rule_host.substr(1),
+                       base::CompareCase::SENSITIVE)) {
+      return true;
+    }
+
+    // Check |url_host| is exactly |rule_host| without the wildcard. i.e. if
+    // |rule_host| is "*.test.xyz", check |url_host| is exactly "test.xyz".
+    return base::CompareCaseInsensitiveASCII(url_host, rule_host.substr(2)) ==
+           0;
+  }
+  return base::CompareCaseInsensitiveASCII(url_host, rule_host) == 0;
+}
+
 void ApplyRule(network::ResourceRequest* request,
                const mojom::UrlRequestRewriteRulePtr& rule) {
   const GURL& url = request->url;
 
   if (rule->hosts_filter) {
     bool found = false;
-    for (const auto& host : rule->hosts_filter.value()) {
-      if (url.host().compare(host) == 0) {
-        found = true;
+    for (const base::StringPiece host : rule->hosts_filter.value()) {
+      if ((found = HostMatches(url.host(), host)))
         break;
-      }
     }
     if (!found)
       return;

fuchsia/engine/common/web_engine_url_loader_throttle.h

@@ -33,13 +33,13 @@ class WebEngineURLLoaderThrottle : public blink::URLLoaderThrottle {
       CachedRulesProvider* cached_rules_provider);
   ~WebEngineURLLoaderThrottle() override;
 
- private:
   // blink::URLLoaderThrottle implementation.
   void DetachFromCurrentSequence() override;
   void WillStartRequest(network::ResourceRequest* request,
                         bool* defer) override;
   bool makes_unsafe_redirect() override;
 
+ private:
   CachedRulesProvider* const cached_rules_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(WebEngineURLLoaderThrottle);

fuchsia/engine/common/web_engine_url_loader_throttle_unittest.cc

+// Copyright 2019 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 "fuchsia/engine/common/web_engine_url_loader_throttle.h"
+
+#include "base/test/task_environment.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class TestCachedRulesProvider
+    : public WebEngineURLLoaderThrottle::CachedRulesProvider {
+ public:
+  TestCachedRulesProvider() = default;
+  ~TestCachedRulesProvider() override = default;
+
+  void SetCachedRules(
+      scoped_refptr<WebEngineURLLoaderThrottle::UrlRequestRewriteRules>
+          cached_rules) {
+    cached_rules_ = cached_rules;
+  }
+
+  // WebEngineURLLoaderThrottle::CachedRulesProvider implementation.
+  scoped_refptr<WebEngineURLLoaderThrottle::UrlRequestRewriteRules>
+  GetCachedRules() override {
+    return cached_rules_;
+  }
+
+ private:
+  scoped_refptr<WebEngineURLLoaderThrottle::UrlRequestRewriteRules>
+      cached_rules_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCachedRulesProvider);
+};
+
+}  // namespace
+
+class WebEngineURLLoaderThrottleTest : public testing::Test {
+ public:
+  WebEngineURLLoaderThrottleTest()
+      : task_environment_(base::test::TaskEnvironment::MainThreadType::IO) {}
+  ~WebEngineURLLoaderThrottleTest() override = default;
+
+ protected:
+  base::test::SingleThreadTaskEnvironment task_environment_;
+};
+
+// Tests rules are properly applied when wildcard-filtering is used on hosts.
+TEST_F(WebEngineURLLoaderThrottleTest, WildcardHosts) {
+  mojom::UrlRequestRewriteAddHeadersPtr add_headers =
+      mojom::UrlRequestRewriteAddHeaders::New();
+  add_headers->headers.SetHeader("Header", "Value");
+  mojom::UrlRequestRewritePtr rewrite =
+      mojom::UrlRequestRewrite::NewAddHeaders(std::move(add_headers));
+  std::vector<mojom::UrlRequestRewritePtr> rewrites;
+  rewrites.push_back(std::move(rewrite));
+  mojom::UrlRequestRewriteRulePtr rule = mojom::UrlRequestRewriteRule::New();
+  rule->hosts_filter = base::Optional<std::vector<std::string>>({"*.test.net"});
+  rule->rewrites = std::move(rewrites);
+
+  std::vector<mojom::UrlRequestRewriteRulePtr> rules;
+  rules.push_back(std::move(rule));
+
+  TestCachedRulesProvider provider;
+  provider.SetCachedRules(
+      base::MakeRefCounted<WebEngineURLLoaderThrottle::UrlRequestRewriteRules>(
+          std::move(rules)));
+
+  WebEngineURLLoaderThrottle throttle(&provider);
+  bool defer = false;
+
+  network::ResourceRequest request1;
+  request1.url = GURL("http://test.net");
+  throttle.WillStartRequest(&request1, &defer);
+  EXPECT_TRUE(request1.headers.HasHeader("Header"));
+
+  network::ResourceRequest request2;
+  request2.url = GURL("http://subdomain.test.net");
+  throttle.WillStartRequest(&request2, &defer);
+  EXPECT_TRUE(request2.headers.HasHeader("Header"));
+
+  network::ResourceRequest request3;
+  request3.url = GURL("http://domaintest.net");
+  throttle.WillStartRequest(&request3, &defer);
+  EXPECT_FALSE(request3.headers.HasHeader("Header"));
+
+  network::ResourceRequest request4;
+  request4.url = GURL("http://otherdomain.net");
+  throttle.WillStartRequest(&request4, &defer);
+  EXPECT_FALSE(request4.headers.HasHeader("Header"));
+}