Render process changes for ResourceTiming sizes.

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 898 matching lines @@
         moveResourceLoaderToNonBlocking(resource->loader());
     else
         removeResourceLoader(resource->loader());
     DCHECK(!m_loaders.contains(resource->loader()));
     DCHECK(finishReason == DidFinishFirstPartInMultipart || !m_nonBlockingLoaders.contains(resource->loader()));
 
     if (std::unique_ptr<ResourceTimingInfo> info = m_resourceTimingInfoMap.take(resource)) {
         if (resource->response().isHTTP() && resource->response().httpStatusCode() < 400) {
             populateResourceTiming(info.get(), resource);
             info->setLoadFinishTime(finishTime);
+            info->addFinalTransferSize(encodedDataLength);
             if (resource->options().requestInitiatorContext == DocumentContext)
                 context().addResourceTiming(*info);
             resource->reportResourceTimingToClients(*info);
         }
     }
     context().dispatchDidFinishLoading(resource->identifier(), finishTime, encodedDataLength);
     if (finishReason == DidFinishLoading)
         resource->finish(finishTime);
     context().didLoadResource(resource);
 }
@@ skipping 97 matching lines @@
 bool ResourceFetcher::defersLoading() const
 {
     return context().defersLoading();
 }
 
 static bool isManualRedirectFetchRequest(const ResourceRequest& request)
 {
     return request.fetchRedirectMode() == WebURLRequest::FetchRedirectModeManual && request.requestContext() == WebURLRequest::RequestContextFetch;
 }
 
-bool ResourceFetcher::willFollowRedirect(Resource* resource, ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
+bool ResourceFetcher::willFollowRedirect(Resource* resource, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, int64_t encodedDataLength)
 {
     if (!isManualRedirectFetchRequest(resource->resourceRequest())) {
         if (!context().canRequest(resource->getType(), newRequest, newRequest.url(), resource->options(), resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
             return false;
         if (resource->options().corsEnabled == IsCORSEnabled) {
             SecurityOrigin* sourceOrigin = resource->options().securityOrigin.get();
             if (!sourceOrigin)
                 sourceOrigin = context().getSecurityOrigin();
 
             String errorMessage;
             StoredCredentials withCredentials = resource->lastResourceRequest().allowStoredCredentials() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
             if (!CrossOriginAccessControl::handleRedirect(sourceOrigin, newRequest, redirectResponse, withCredentials, resource->mutableOptions(), errorMessage)) {
                 resource->setCORSFailed();
                 context().addConsoleMessage(errorMessage);
                 return false;
             }
         }
         if (resource->getType() == Resource::Image && shouldDeferImageLoad(newRequest.url()))
             return false;
     }
 
     ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
-    if (it != m_resourceTimingInfoMap.end())
-        it->value->addRedirect(redirectResponse);
+    if (it != m_resourceTimingInfoMap.end()) {
+        RefPtr<SecurityOrigin> redirectedSecurityOrigin = SecurityOrigin::create(redirectResponse.url());
+        bool crossOrigin = !redirectedSecurityOrigin->canRequest(newRequest.url());
+        it->value->addRedirect(redirectResponse, encodedDataLength, crossOrigin);
+    }
     willSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options());
     return true;
 }
 
 void ResourceFetcher::willSendRequest(unsigned long identifier, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
 {
     newRequest.setAllowStoredCredentials(options.allowCredentials == AllowStoredCredentials);
     context().dispatchWillSendRequest(identifier, newRequest, redirectResponse, options.initiatorInfo);
 }
 
@@ skipping 190 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