Don't use FetchRequest in FrameFetchContext

third_party/WebKit/Source/core/loader/FrameFetchContextTest.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 154 matching lines @@
                   WebURLRequest::FrameTypeNone, expected);
   }
 
   void expectUpgrade(const char* input,
                      WebURLRequest::RequestContext requestContext,
                      WebURLRequest::FrameType frameType,
                      const char* expected) {
     KURL inputURL(ParsedURLString, input);
     KURL expectedURL(ParsedURLString, expected);
 
-    FetchRequest fetchRequest =
-        FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo());
-    fetchRequest.mutableResourceRequest().setRequestContext(requestContext);
-    fetchRequest.mutableResourceRequest().setFrameType(frameType);
+    ResourceRequest resourceRequest(inputURL);
+    resourceRequest.setRequestContext(requestContext);
+    resourceRequest.setFrameType(frameType);
 
-    fetchContext->modifyRequestForCSP(fetchRequest.mutableResourceRequest());
+    fetchContext->modifyRequestForCSP(resourceRequest);
 
-    EXPECT_EQ(expectedURL.getString(),
-              fetchRequest.resourceRequest().url().getString());
-    EXPECT_EQ(expectedURL.protocol(),
-              fetchRequest.resourceRequest().url().protocol());
-    EXPECT_EQ(expectedURL.host(), fetchRequest.resourceRequest().url().host());
-    EXPECT_EQ(expectedURL.port(), fetchRequest.resourceRequest().url().port());
-    EXPECT_EQ(expectedURL.hasPort(),
-              fetchRequest.resourceRequest().url().hasPort());
-    EXPECT_EQ(expectedURL.path(), fetchRequest.resourceRequest().url().path());
+    EXPECT_EQ(expectedURL.getString(), resourceRequest.url().getString());
+    EXPECT_EQ(expectedURL.protocol(), resourceRequest.url().protocol());
+    EXPECT_EQ(expectedURL.host(), resourceRequest.url().host());
+    EXPECT_EQ(expectedURL.port(), resourceRequest.url().port());
+    EXPECT_EQ(expectedURL.hasPort(), resourceRequest.url().hasPort());
+    EXPECT_EQ(expectedURL.path(), resourceRequest.url().path());
   }
 
   void expectUpgradeInsecureRequestHeader(const char* input,
                                           WebURLRequest::FrameType frameType,
                                           bool shouldPrefer) {
     KURL inputURL(ParsedURLString, input);
 
-    FetchRequest fetchRequest =
-        FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo());
-    fetchRequest.mutableResourceRequest().setRequestContext(
-        WebURLRequest::RequestContextScript);
-    fetchRequest.mutableResourceRequest().setFrameType(frameType);
+    ResourceRequest resourceRequest(inputURL);
+    resourceRequest.setRequestContext(WebURLRequest::RequestContextScript);
+    resourceRequest.setFrameType(frameType);
 
-    fetchContext->modifyRequestForCSP(fetchRequest.mutableResourceRequest());
+    fetchContext->modifyRequestForCSP(resourceRequest);
 
-    EXPECT_EQ(shouldPrefer ? String("1") : String(),
-              fetchRequest.resourceRequest().httpHeaderField(
-                  HTTPNames::Upgrade_Insecure_Requests));
+    EXPECT_EQ(
+        shouldPrefer ? String("1") : String(),
+        resourceRequest.httpHeaderField(HTTPNames::Upgrade_Insecure_Requests));
 
     // Calling modifyRequestForCSP more than once shouldn't affect the
     // header.
     if (shouldPrefer) {
-      fetchContext->modifyRequestForCSP(fetchRequest.mutableResourceRequest());
-      EXPECT_EQ("1", fetchRequest.resourceRequest().httpHeaderField(
+      fetchContext->modifyRequestForCSP(resourceRequest);
+      EXPECT_EQ("1", resourceRequest.httpHeaderField(
                          HTTPNames::Upgrade_Insecure_Requests));
     }
   }
 
   void expectSetEmbeddingCSPRequestHeader(
       const char* input,
       WebURLRequest::FrameType frameType,
       const AtomicString& expectedEmbeddingCSP) {
     KURL inputURL(ParsedURLString, input);
+    ResourceRequest resourceRequest(inputURL);
+    resourceRequest.setRequestContext(WebURLRequest::RequestContextScript);
+    resourceRequest.setFrameType(frameType);
 
-    FetchRequest fetchRequest =
-        FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo());
-    fetchRequest.mutableResourceRequest().setRequestContext(
-        WebURLRequest::RequestContextScript);
-    fetchRequest.mutableResourceRequest().setFrameType(frameType);
-
-    fetchContext->modifyRequestForCSP(fetchRequest.mutableResourceRequest());
+    fetchContext->modifyRequestForCSP(resourceRequest);
 
     EXPECT_EQ(expectedEmbeddingCSP,
-              fetchRequest.resourceRequest().httpHeaderField(
-                  HTTPNames::Embedding_CSP));
+              resourceRequest.httpHeaderField(HTTPNames::Embedding_CSP));
   }
 
   void setFrameOwnerBasedOnFrameType(WebURLRequest::FrameType frameType,
                                      HTMLIFrameElement* iframe,
                                      const AtomicString& potentialValue) {
     if (frameType != WebURLRequest::FrameTypeNested) {
       document->frame()->setOwner(nullptr);
       return;
     }
 
@@ skipping 166 matching lines @@
 class FrameFetchContextHintsTest : public FrameFetchContextTest {
  public:
   FrameFetchContextHintsTest() {}
 
  protected:
   void expectHeader(const char* input,
                     const char* headerName,
                     bool isPresent,
                     const char* headerValue,
                     float width = 0) {
-    KURL inputURL(ParsedURLString, input);
-    FetchRequest fetchRequest =
-        FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo());
+    ClientHintsPreferences hintsPreferences;
+
+    FetchRequest::ResourceWidth resourceWidth;
     if (width > 0) {
-      FetchRequest::ResourceWidth resourceWidth;
       resourceWidth.width = width;
       resourceWidth.isSet = true;
-      fetchRequest.setResourceWidth(resourceWidth);
     }
-    fetchContext->addClientHintsIfNecessary(fetchRequest);
+
+    KURL inputURL(ParsedURLString, input);
+    ResourceRequest resourceRequest(inputURL);
+
+    fetchContext->addClientHintsIfNecessary(hintsPreferences, resourceWidth,
+                                            resourceRequest);
 
     EXPECT_EQ(isPresent ? String(headerValue) : String(),
-              fetchRequest.resourceRequest().httpHeaderField(headerName));
+              resourceRequest.httpHeaderField(headerName));
   }
 };
 
 TEST_F(FrameFetchContextHintsTest, MonitorDPRHints) {
   expectHeader("http://www.example.com/1.gif", "DPR", false, "");
   ClientHintsPreferences preferences;
   preferences.setShouldSendDPR(true);
   document->clientHintsPreferences().updateFrom(preferences);
   expectHeader("http://www.example.com/1.gif", "DPR", true, "1");
   dummyPageHolder->page().setDeviceScaleFactor(2.5);
@@ skipping 93 matching lines @@
             childFetchContext->resourceRequestCachePolicy(
                 request, Resource::MainResource, FetchRequest::NoDefer));
 
   // Child frame as part of reload bypassing cache
   document->frame()->loader().setLoadType(FrameLoadTypeReloadBypassingCache);
   EXPECT_EQ(WebCachePolicy::BypassingCache,
             childFetchContext->resourceRequestCachePolicy(
                 request, Resource::MainResource, FetchRequest::NoDefer));
 }
 
-TEST_F(FrameFetchContextTest, PopulateRequestData) {
+TEST_F(FrameFetchContextTest, SetFirstPartyCookieAndRequestorOrigin) {
   struct TestCase {
     const char* documentURL;
     bool documentSandboxed;
     const char* requestorOrigin;  // "" => unique origin
     WebURLRequest::FrameType frameType;
     const char* serializedOrigin;  // "" => unique origin
   } cases[] = {
       // No document origin => unique request origin
       {"", false, "", WebURLRequest::FrameTypeNone, "null"},
       {"", true, "", WebURLRequest::FrameTypeNone, "null"},
 
       // Document origin => request origin
       {"http://example.test", false, "", WebURLRequest::FrameTypeNone,
        "http://example.test"},
       {"http://example.test", true, "", WebURLRequest::FrameTypeNone,
        "http://example.test"},
 
       // If the request already has a requestor origin, then
-      // 'populateRequestData' leaves it alone:
+      // 'setFirstPartyCookieAndRequestorOrigin' leaves it alone:
       {"http://example.test", false, "http://not-example.test",
        WebURLRequest::FrameTypeNone, "http://not-example.test"},
       {"http://example.test", true, "http://not-example.test",
        WebURLRequest::FrameTypeNone, "http://not-example.test"},
 
-      // If the request's frame type is not 'none', then 'populateRequestData'
+      // If the request's frame type is not 'none', then
+      // 'setFirstPartyCookieAndRequestorOrigin'
       // leaves it alone:
       {"http://example.test", false, "", WebURLRequest::FrameTypeTopLevel, ""},
       {"http://example.test", false, "", WebURLRequest::FrameTypeAuxiliary, ""},
       {"http://example.test", false, "", WebURLRequest::FrameTypeNested, ""},
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(::testing::Message() << test.documentURL << " => "
                                       << test.serializedOrigin);
     // Set up a new document to ensure sandbox flags are cleared:
@@ skipping 10 matching lines @@
       document->enforceSandboxFlags(SandboxOrigin);
 
     ResourceRequest request("http://example.test/");
     request.setFrameType(test.frameType);
     if (strlen(test.requestorOrigin) > 0) {
       request.setRequestorOrigin(
           SecurityOrigin::create(KURL(ParsedURLString, test.requestorOrigin)));
     }
 
     // Compare the populated |requestorOrigin| against |test.serializedOrigin|
-    fetchContext->populateRequestData(request);
+    fetchContext->setFirstPartyCookieAndRequestorOrigin(request);
     if (strlen(test.serializedOrigin) == 0) {
       EXPECT_TRUE(request.requestorOrigin()->isUnique());
     } else {
       EXPECT_EQ(String(test.serializedOrigin),
                 request.requestorOrigin()->toString());
     }
 
     EXPECT_EQ(document->firstPartyForCookies(), request.firstPartyForCookies());
   }
 }
 
 TEST_F(FrameFetchContextTest, ModifyPriorityForLowPriorityIframes) {
   Settings* settings = document->frame()->settings();
   settings->setLowPriorityIframes(false);
-  FetchRequest request(ResourceRequest("http://www.example.com"),
-                       FetchInitiatorInfo());
   FrameFetchContext* childFetchContext = createChildFrame();
 
   // No low priority iframes, expect default values.
   EXPECT_EQ(ResourceLoadPriorityVeryHigh,
             childFetchContext->modifyPriorityForExperiments(
                 ResourceLoadPriorityVeryHigh));
   EXPECT_EQ(ResourceLoadPriorityMedium,
             childFetchContext->modifyPriorityForExperiments(
                 ResourceLoadPriorityMedium));
 
@@ skipping 180 matching lines @@
     fetchContext->addAdditionalRequestHeaders(mainRequest, FetchMainResource);
     EXPECT_EQ(test.isExternalExpectation, mainRequest.isExternalRequest());
 
     ResourceRequest subRequest(test.url);
     fetchContext->addAdditionalRequestHeaders(subRequest, FetchSubresource);
     EXPECT_EQ(test.isExternalExpectation, subRequest.isExternalRequest());
   }
 }
 
 }  // namespace blink