Split header modification out of willSendRequest

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
     License as published by the Free Software Foundation; either
@@ skipping 414 matching lines @@
         return nullptr;
 
     if (!context().canRequest(factory.type(), request.resourceRequest(), MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), request.options(), request.forPreload(), request.getOriginRestriction()))
         return nullptr;
 
     unsigned long identifier = createUniqueIdentifier();
     request.setPriority(loadPriority(factory.type(), request, ResourcePriority::NotVisible));
     request.mutableResourceRequest().setPriority(request.priority());
     initializeResourceRequest(request.mutableResourceRequest(), factory.type(), request.defer());
     context().willStartLoadingResource(identifier, request.mutableResourceRequest(), factory.type());
+    prepareRequest(identifier, request.mutableResourceRequest(), ResourceResponse(), request.options());
     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();
 
@@ skipping 17 matching lines @@
         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(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);
         break;
@@ skipping 526 matching lines @@
 }
 
 bool ResourceFetcher::startLoad(Resource* resource)
 {
     DCHECK(resource && resource->stillNeedsLoad());
     if (!context().shouldLoadNewResource(resource->getType())) {
         memoryCache()->remove(resource);
         return false;
     }
 
-    ResourceRequest request(resource->resourceRequest());
-    willSendRequest(resource->identifier(), request, ResourceResponse(), resource->options());
-
     ResourceLoader* loader = ResourceLoader::create(this, resource);
     if (resource->shouldBlockLoadEvent())
         m_loaders.add(loader);
     else
         m_nonBlockingLoaders.add(loader);
 
+    context().dispatchWillSendRequest(resource->identifier(), resource->resourceRequest(), ResourceResponse(), resource->options().initiatorInfo);
     storeResourceTimingInitiatorInformation(resource);
     resource->setFetcherSecurityOrigin(context().getSecurityOrigin());
-    loader->start(request, context().loadingTaskRunner(), context().defersLoading());
+    loader->start(resource->resourceRequest(), context().loadingTaskRunner(), context().defersLoading());

[Shao-Chuan Lee, 2016/10/06 03:34:41]

Maybe we can now remove the first param in ResourceLoader::start() and use
m_resource->resourceRequest()?

     return true;
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader)
 {
     if (m_loaders.contains(loader))
         m_loaders.remove(loader);
     else if (m_nonBlockingLoaders.contains(loader))
         m_nonBlockingLoaders.remove(loader);
     else
@@ skipping 49 matching lines @@
             return false;
     }
 
     ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
     if (it != m_resourceTimingInfoMap.end()) {
         RefPtr<SecurityOrigin> originalSecurityOrigin = SecurityOrigin::create(redirectResponse.url());
         RefPtr<SecurityOrigin> redirectedSecurityOrigin = SecurityOrigin::create(newRequest.url());
         bool crossOrigin = !redirectedSecurityOrigin->isSameSchemeHostPort(originalSecurityOrigin.get());
         it->value->addRedirect(redirectResponse, encodedDataLength, crossOrigin);
     }
-    newRequest.setAllowStoredCredentials(resource->options().allowCredentials == AllowStoredCredentials);
-    willSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options());
+    prepareRequest(resource->identifier(), newRequest, redirectResponse, resource->options());
+    context().dispatchWillSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options().initiatorInfo);
     return true;
 }
 
-void ResourceFetcher::willSendRequest(unsigned long identifier, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
+void ResourceFetcher::prepareRequest(unsigned long identifier, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
 {
-    context().dispatchWillSendRequest(identifier, newRequest, redirectResponse, options.initiatorInfo);
+    newRequest.setAllowStoredCredentials(options.allowCredentials == AllowStoredCredentials);
+    context().prepareRequest(identifier, newRequest, redirectResponse);
 }
 
 void ResourceFetcher::updateAllImageResourcePriorities()
 {
     TRACE_EVENT0("blink", "ResourceLoadPriorityOptimizer::updateAllImageResourcePriorities");
     for (const auto& documentResource : m_documentResources) {
         Resource* resource = documentResource.value.get();
         if (!resource || !resource->isImage() || !resource->isLoading())
             continue;
 
@@ skipping 182 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