Implement CanRequest in BaseFetchContext

third_party/WebKit/Source/core/loader/BaseFetchContextTest.cpp

 /*
  * Copyright (c) 2015, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/loader/BaseFetchContext.h"
 
-#include "core/testing/NullExecutionContext.h"
+#include "core/dom/Document.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
+class MockBaseFetchContext final : public BaseFetchContext {
+ public:
+  explicit MockBaseFetchContext(ExecutionContext* execution_context)
+      : BaseFetchContext(execution_context) {}
+  ~MockBaseFetchContext() override {}
+
+  // BaseFetchContext overrides:
+  ContentSettingsClient* GetContentSettingsClient() const override {
+    return nullptr;
+  }
+  Settings* GetSettings() const override { return nullptr; }
+  SubresourceFilter* GetSubresourceFilter() const override { return nullptr; }
+  SecurityContext* GetMainResourceSecurityContext() const override {
+    return nullptr;
+  }
+  bool ShouldBlockRequestByInspector(const ResourceRequest&) const override {
+    return false;
+  }
+  void DispatchDidBlockRequest(const ResourceRequest&,
+                               const FetchInitiatorInfo&,
+                               ResourceRequestBlockedReason) const override {}
+  void ReportLocalLoadFailed(const KURL&) const override {}
+  bool ShouldBypassMainWorldCSP() const override { return false; }
+  bool IsSVGImageChromeClient() const override { return false; }
+  void CountUsage(UseCounter::Feature) const override {}
+  void CountDeprecation(UseCounter::Feature) const override {}
+  bool ShouldBlockFetchByMixedContentCheck(
+      const ResourceRequest&,
+      const KURL&,
+      SecurityViolationReportingPolicy) const override {
+    return false;
+  }
+};
+
 class BaseFetchContextTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    execution_context_ = new NullExecutionContext();
-    fetch_context_ = new BaseFetchContext(execution_context_);
+    execution_context_ = Document::Create();

[Nate Chapin, 2017/04/21 18:33:07]

Why is this change necessary?

[kinuko, 2017/04/24 06:05:27]

NullExecutionContext doesn't have ContentSecurityPolicy. I've reverted this line
but instead added some support code to test CSP with NullExecutionContext.

+    fetch_context_ = new MockBaseFetchContext(execution_context_);
   }
 
   Persistent<ExecutionContext> execution_context_;
   Persistent<BaseFetchContext> fetch_context_;
 };
 
 TEST_F(BaseFetchContextTest, SetIsExternalRequestForPublicContext) {
   EXPECT_EQ(kWebAddressSpacePublic,
             execution_context_->GetSecurityContext().AddressSpace());
 
@@ skipping 121 matching lines @@
     fetch_context_->AddAdditionalRequestHeaders(main_request,
                                                 kFetchMainResource);
     EXPECT_EQ(test.is_external_expectation, main_request.IsExternalRequest());
 
     ResourceRequest sub_request(test.url);
     fetch_context_->AddAdditionalRequestHeaders(sub_request, kFetchSubresource);
     EXPECT_EQ(test.is_external_expectation, sub_request.IsExternalRequest());
   }
 }
 
+// Tests that CanFollowRedirect() checks both report-only and enforced CSP
+// headers.
+TEST_F(BaseFetchContextTest, RedirectChecksReportedAndEnforcedCSP) {
+  ContentSecurityPolicy* policy =
+      execution_context_->GetContentSecurityPolicy();
+  policy->DidReceiveHeader("script-src https://foo.test",
+                           kContentSecurityPolicyHeaderTypeEnforce,
+                           kContentSecurityPolicyHeaderSourceHTTP);
+  policy->DidReceiveHeader("script-src https://bar.test",
+                           kContentSecurityPolicyHeaderTypeReport,
+                           kContentSecurityPolicyHeaderSourceHTTP);
+  KURL url(KURL(), "http://baz.test");
+  ResourceRequest resource_request(url);
+  resource_request.SetRequestContext(WebURLRequest::kRequestContextScript);
+  EXPECT_EQ(
+      ResourceRequestBlockedReason::CSP,
+      fetch_context_->CanFollowRedirect(
+          Resource::kScript, resource_request, url, ResourceLoaderOptions(),
+          SecurityViolationReportingPolicy::kReport,
+          FetchParameters::kUseDefaultOriginRestrictionForType));
+  EXPECT_EQ(2u, policy->violation_reports_sent_.size());
+}
+
+// Tests that AllowResponse() checks both report-only and enforced CSP headers.
+TEST_F(BaseFetchContextTest, AllowResponseChecksReportedAndEnforcedCSP) {
+  ContentSecurityPolicy* policy =
+      execution_context_->GetContentSecurityPolicy();
+  policy->DidReceiveHeader("script-src https://foo.test",
+                           kContentSecurityPolicyHeaderTypeEnforce,
+                           kContentSecurityPolicyHeaderSourceHTTP);
+  policy->DidReceiveHeader("script-src https://bar.test",
+                           kContentSecurityPolicyHeaderTypeReport,
+                           kContentSecurityPolicyHeaderSourceHTTP);
+  KURL url(KURL(), "http://baz.test");
+  ResourceRequest resource_request(url);
+  resource_request.SetRequestContext(WebURLRequest::kRequestContextScript);
+  EXPECT_EQ(ResourceRequestBlockedReason::CSP,
+            fetch_context_->AllowResponse(Resource::kScript, resource_request,
+                                          url, ResourceLoaderOptions()));
+  EXPECT_EQ(2u, policy->violation_reports_sent_.size());
+}
+
 }  // namespace blink