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 410 matching lines @@
                     float width = 0) {
     KURL inputURL(ParsedURLString, input);
     FetchRequest fetchRequest =
         FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo());
     if (width > 0) {
       FetchRequest::ResourceWidth resourceWidth;
       resourceWidth.width = width;
       resourceWidth.isSet = true;
       fetchRequest.setResourceWidth(resourceWidth);
     }
-    fetchContext->addClientHintsIfNecessary(fetchRequest);
+    fetchContext->addClientHintsIfNecessary(
+        fetchRequest.clientHintsPreferences(), fetchRequest.getResourceWidth(),
+        fetchRequest.mutableResourceRequest());
 
     EXPECT_EQ(isPresent ? String(headerValue) : String(),
               fetchRequest.resourceRequest().httpHeaderField(headerName));
   }
 };
 
 TEST_F(FrameFetchContextHintsTest, MonitorDPRHints) {
   expectHeader("http://www.example.com/1.gif", "DPR", false, "");
   ClientHintsPreferences preferences;
   preferences.setShouldSendDPR(true);
@@ skipping 96 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());
   }
 }
@@ skipping 196 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