Refactor mutable ResourceRequest in ResourceFetcher

third_party/WebKit/Source/platform/loader/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 445 matching lines @@
     DEFINE_RESOURCE_HISTOGRAM("Dead.");
   }
 }
 
 ResourceFetcher::PrepareRequestResult ResourceFetcher::prepareRequest(
     FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData,
     unsigned long identifier,
     ResourceRequestBlockedReason& blockedReason) {
-  ResourceRequest& resourceRequest = request.mutableResourceRequest();
 
   DCHECK(request.options().synchronousPolicy == RequestAsynchronously ||
          factory.type() == Resource::Raw ||
          factory.type() == Resource::XSLStyleSheet);
 
   context().populateResourceRequest(
       factory.type(), request.clientHintsPreferences(),
-      request.getResourceWidth(), resourceRequest);
+      request.getResourceWidth(), request.mutableResourceRequest());
 
   if (!request.url().isValid())
     return Abort;
 
-  resourceRequest.setPriority(computeLoadPriority(
+  request.mutableResourceRequest().setPriority(computeLoadPriority(
       factory.type(), request.resourceRequest(), ResourcePriority::NotVisible,
       request.defer(), request.isSpeculativePreload()));
-  initializeResourceRequest(resourceRequest, factory.type(), request.defer());
-  network_instrumentation::resourcePrioritySet(identifier,
-                                               resourceRequest.priority());
+  initializeResourceRequest(request.mutableResourceRequest(), factory.type(),
+                            request.defer());
+  network_instrumentation::resourcePrioritySet(
+      identifier, request.resourceRequest().priority());
 
   blockedReason = context().canRequest(
-      factory.type(), resourceRequest,
+      factory.type(), request.resourceRequest(),
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()),
       request.options(),
       /* Don't send security violation reports for speculative preloads */
       request.isSpeculativePreload()
           ? SecurityViolationReportingPolicy::SuppressReporting
           : SecurityViolationReportingPolicy::Report,
       request.getOriginRestriction());
   if (blockedReason != ResourceRequestBlockedReason::None) {
     DCHECK(!substituteData.forceSynchronousLoad());
     return Block;
   }
 
   context().willStartLoadingResource(
-      identifier, resourceRequest, factory.type(),
+      identifier, request.mutableResourceRequest(), factory.type(),
       request.options().initiatorInfo.name,
       (request.isSpeculativePreload()
            ? FetchContext::V8ActivityLoggingPolicy::SuppressLogging
            : FetchContext::V8ActivityLoggingPolicy::Log));
   if (!request.url().isValid())
     return Abort;
 
-  resourceRequest.setAllowStoredCredentials(
+  request.mutableResourceRequest().setAllowStoredCredentials(
       request.options().allowCredentials == AllowStoredCredentials);
   return Continue;
 }
 
 Resource* ResourceFetcher::requestResource(
     FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
   unsigned long identifier = createUniqueIdentifier();
-  ResourceRequest& resourceRequest = request.mutableResourceRequest();
   network_instrumentation::ScopedResourceLoadTracker scopedResourceLoadTracker(
-      identifier, resourceRequest);
+      identifier, request.resourceRequest());
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Fetch.RequestResourceTime");
   // TODO(dproy): Remove this. http://crbug.com/659666
   TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
                urlForTraceEvent(request.url()));
 
   Resource* resource = nullptr;
   ResourceRequestBlockedReason blockedReason =
       ResourceRequestBlockedReason::None;
 
   PrepareRequestResult result = prepareRequest(request, factory, substituteData,
                                                identifier, blockedReason);
   if (result == Abort)
     return nullptr;
   if (result == Block)
     return resourceForBlockedRequest(request, factory, blockedReason);
 
-  bool isDataUrl = resourceRequest.url().protocolIsData();
+  bool isDataUrl = request.url().protocolIsData();
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   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;
   }
@@ skipping 14 matching lines @@
   updateMemoryCacheStats(resource, policy, request, factory, isStaticData);
 
   switch (policy) {
     case Reload:
       memoryCache()->remove(resource);
     // Fall through
     case Load:
       resource = createResourceForLoading(request, request.charset(), factory);
       break;
     case Revalidate:
-      initializeRevalidation(resourceRequest, resource);
+      initializeRevalidation(request.mutableResourceRequest(), resource);
       break;
     case Use:
       if (resource->isLinkPreload() && !request.isLinkPreload())
         resource->setLinkPreload(false);
       break;
   }
   if (!resource)
     return nullptr;
 
   // TODO(yoav): turn to a DCHECK. See https://crbug.com/690632
   CHECK_EQ(resource->getType(), factory.type());
 
   if (!resource->isAlive())
     m_deadStatsRecorder.update(policy);
 
   if (policy != Use)
     resource->setIdentifier(identifier);
 
   // TODO(yoav): It is not clear why preloads are exempt from this check. Can we
   // remove the exemption?
   if (!request.isSpeculativePreload() || 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 (resourceRequest.priority() > resource->resourceRequest().priority())
-      resource->didChangePriority(resourceRequest.priority(), 0);
+    if (request.resourceRequest().priority() >
+        resource->resourceRequest().priority())
+      resource->didChangePriority(request.resourceRequest().priority(), 0);
     // TODO(yoav): I'd expect the stated scenario to not go here, as its policy
     // would be Use.
   }
 
   // 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);
@@ skipping 931 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