Don't use FetchRequest in FrameFetchContext

third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 484 matching lines @@
   if (resource && !resource->isAlive() &&
       (!m_preloads || !m_preloads->contains(resource))) {
     DEFINE_RESOURCE_HISTOGRAM("Dead.");
   }
 }
 
 Resource* ResourceFetcher::requestResource(
     FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
+  ResourceRequest& resourceRequest = request.mutableResourceRequest();
+
   unsigned long identifier = createUniqueIdentifier();
   network_instrumentation::ScopedResourceLoadTracker scopedResourceLoadTracker(
-      identifier, request.resourceRequest());
+      identifier, resourceRequest);
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Fetch.RequestResourceTime");
   DCHECK(request.options().synchronousPolicy == RequestAsynchronously ||
          factory.type() == Resource::Raw ||
          factory.type() == Resource::XSLStyleSheet);
 
-  context().populateRequestData(request.mutableResourceRequest());
-  context().modifyRequestForCSP(request.mutableResourceRequest());
-  context().addClientHintsIfNecessary(request);
-  context().addCSPHeaderIfNecessary(factory.type(), request);
+  context().populateResourceRequest(
+      factory.type(), request.clientHintsPreferences(),
+      request.getResourceWidth(), resourceRequest);
 
   // TODO(dproy): Remove this. http://crbug.com/659666
   TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
                urlForTraceEvent(request.url()));
 
   if (!request.url().isValid())
     return nullptr;
 
-  request.mutableResourceRequest().setPriority(computeLoadPriority(
+  resourceRequest.setPriority(computeLoadPriority(
       factory.type(), request, ResourcePriority::NotVisible));
-  initializeResourceRequest(request.mutableResourceRequest(), factory.type(),
-                            request.defer());
-  network_instrumentation::resourcePrioritySet(
-      identifier, request.resourceRequest().priority());
+  initializeResourceRequest(resourceRequest, factory.type(), request.defer());
+  network_instrumentation::resourcePrioritySet(identifier,
+                                               resourceRequest.priority());
 
   ResourceRequestBlockedReason blockedReason = context().canRequest(
-      factory.type(), request.resourceRequest(),
+      factory.type(), resourceRequest,
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()),
       request.options(), request.forPreload(), request.getOriginRestriction());
   if (blockedReason != ResourceRequestBlockedReason::None) {
     DCHECK(!substituteData.forceSynchronousLoad());
     return resourceForBlockedRequest(request, factory, blockedReason);
   }
 
-  context().willStartLoadingResource(
-      identifier, request.mutableResourceRequest(), factory.type());
+  context().willStartLoadingResource(identifier, resourceRequest,
+                                     factory.type());
   if (!request.url().isValid())
     return nullptr;
 
   if (!request.forPreload()) {
     V8DOMActivityLogger* activityLogger = nullptr;
     if (request.options().initiatorInfo.name ==
         FetchInitiatorTypeNames::xmlhttprequest) {
       activityLogger = V8DOMActivityLogger::currentActivityLogger();
     } else {
       activityLogger =
           V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
     }
 
     if (activityLogger) {
       Vector<String> argv;
       argv.append(Resource::resourceTypeToString(
           factory.type(), request.options().initiatorInfo));
       argv.append(request.url());
       activityLogger->logEvent("blinkRequestResource", argv.size(),
                                argv.data());
     }
   }
 
-  bool isDataUrl = request.resourceRequest().url().protocolIsData();
+  bool isDataUrl = resourceRequest.url().protocolIsData();
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   Resource* resource(nullptr);
   if (isStaticData) {
     resource = resourceForStaticData(request, factory, substituteData);
     // Abort the request if the archive doesn't contain the resource, except in
     // the case of data URLs which might have resources such as fonts that need
     // to be decoded only on demand.  These data URLs are allowed to be
     // processed using the normal ResourceFetcher machinery.
     if (!resource && !isDataUrl && m_archive)
       return nullptr;
   }
   if (!resource) {
     resource =
         memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
   }
 
   // See if we can use an existing resource from the cache. If so, we need to
   // move it to be load blocking.
   moveCachedNonBlockingResourceToBlocking(resource, request);
 
   const RevalidationPolicy policy = determineRevalidationPolicy(
       factory.type(), request, resource, isStaticData);
   TRACE_EVENT_INSTANT1("blink", "ResourceFetcher::determineRevalidationPolicy",
                        TRACE_EVENT_SCOPE_THREAD, "revalidationPolicy", policy);
 
   updateMemoryCacheStats(resource, policy, request, factory, isStaticData);
 
-  request.mutableResourceRequest().setAllowStoredCredentials(
+  resourceRequest.setAllowStoredCredentials(
       request.options().allowCredentials == AllowStoredCredentials);
 
   switch (policy) {
     case Reload:
       memoryCache()->remove(resource);
     // Fall through
     case Load:
       resource = createResourceForLoading(request, request.charset(), factory);
       break;
     case Revalidate:
-      initializeRevalidation(request.mutableResourceRequest(), resource);
+      initializeRevalidation(resourceRequest, resource);
       break;
     case Use:
       if (resource->isLinkPreload() && !request.isLinkPreload())
         resource->setLinkPreload(false);
       break;
   }
   if (!resource)
     return nullptr;
   if (resource->getType() != factory.type()) {
     DCHECK(request.forPreload());
     return nullptr;
   }
 
   if (!resource->isAlive())
     m_deadStatsRecorder.update(policy);
 
   if (policy != Use)
     resource->setIdentifier(identifier);
 
   if (!request.forPreload() || policy != Use) {
     // When issuing another request for a resource that is already in-flight
     // make sure to not demote the priority of the in-flight request. If the new
     // request isn't at the same priority as the in-flight request, only allow
     // promotions. This can happen when a visible image's priority is increased
     // and then another reference to the image is parsed (which would be at a
     // lower priority).
-    if (request.resourceRequest().priority() >
-        resource->resourceRequest().priority())
-      resource->didChangePriority(request.resourceRequest().priority(), 0);
+    if (resourceRequest.priority() > resource->resourceRequest().priority())
+      resource->didChangePriority(resourceRequest.priority(), 0);
   }
 
   // If only the fragment identifiers differ, it is the same resource.
   DCHECK(equalIgnoringFragmentIdentifier(resource->url(), request.url()));
   requestLoadStarted(
       identifier, resource, request,
       policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork,
       isStaticData);
   m_documentResources.set(
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), resource);
@@ skipping 1060 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink