PlzNavigate: Support ResourceTiming API

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 73 matching lines @@
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, MainResource)   \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Manifest)       \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Media)          \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Raw)            \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Script)         \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, SVGDocument)    \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, TextTrack)      \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, XSLStyleSheet)  \
     }
 
+bool IsCrossOrigin(const KURL& a, const KURL& b)
+{
+    RefPtr<SecurityOrigin> originA = SecurityOrigin::create(a);
+    RefPtr<SecurityOrigin> originB = SecurityOrigin::create(b);
+    return !originB->isSameSchemeHostPort(originA.get());
+}
+
 } // namespace
 
 static void RecordSriResourceIntegrityMismatchEvent(SriResourceIntegrityMismatchEvent event)
 {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, integrityHistogram, new EnumerationHistogram("sri.resource_integrity_mismatch_event", SriResourceIntegrityMismatchEventCount));
     integrityHistogram.count(event);
 }
 
 static ResourceLoadPriority typeToPriority(Resource::Type type)
 {
@@ skipping 59 matching lines @@
 
     // A manually set priority acts as a floor. This is used to ensure that synchronous requests
     // are always given the highest possible priority, as well as to ensure that there isn't priority
     // churn if images move in and out of the viewport, or is displayed more than once, both in and out
     // of the viewport.
     return std::max(context().modifyPriorityForExperiments(priority), request.resourceRequest().priority());
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource)
 {
-    info->setInitialRequest(resource->resourceRequest());
+    KURL initialURL = resource->response().redirectResponses().isEmpty()
+        ? resource->resourceRequest().url()
+        : resource->response().redirectResponses()[0].url();
+    info->setInitialURL(initialURL);
     info->setFinalResponse(resource->response());
 }
 
 static WebURLRequest::RequestContext requestContextFromType(bool isMainFrame, Resource::Type type)
 {
     switch (type) {
     case Resource::MainResource:
         if (!isMainFrame)
             return WebURLRequest::RequestContextIframe;
         // FIXME: Change this to a context frame type (once we introduce them): http://fetch.spec.whatwg.org/#concept-request-context-frame-type
@@ skipping 420 matching lines @@
     return resource;
 }
 
 void ResourceFetcher::storeResourceTimingInitiatorInformation(Resource* resource)
 {
     const AtomicString& fetchInitiator = resource->options().initiatorInfo.name;
     if (fetchInitiator == FetchInitiatorTypeNames::internal)
         return;
 
     bool isMainResource = resource->getType() == Resource::MainResource;
-    std::unique_ptr<ResourceTimingInfo> info = ResourceTimingInfo::create(fetchInitiator, monotonicallyIncreasingTime(), isMainResource);
+
+    // The request can already be fetched in a previous navigation. Thus
+    // startTime must be set accordingly.
+    double startTime = resource->resourceRequest().navigationStartTime()
+        ? resource->resourceRequest().navigationStartTime()
+        : monotonicallyIncreasingTime();
+
+    std::unique_ptr<ResourceTimingInfo> info = ResourceTimingInfo::create(fetchInitiator, startTime, isMainResource);
 
     if (resource->isCacheValidator()) {
         const AtomicString& timingAllowOrigin = resource->response().httpHeaderField(HTTPNames::Timing_Allow_Origin);
         if (!timingAllowOrigin.isEmpty())
             info->setOriginalTimingAllowOrigin(timingAllowOrigin);
     }
 
     if (!isMainResource || context().updateTimingInfoForIFrameNavigation(info.get()))
         m_resourceTimingInfoMap.add(resource, std::move(info));
 }
@@ skipping 311 matching lines @@
     // When loading a multipart resource, make the loader non-block when
     // finishing loading the first part.
     if (finishReason == DidFinishFirstPartInMultipart)
         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)) {
+
+        // Store redirect responses that were packed inside the final response.
+        const Vector<ResourceResponse>& responses = resource->response().redirectResponses();
+        for (size_t i = 0; i < responses.size(); ++i) {
+            const KURL& newURL = i + 1 < responses.size() ? KURL(responses[i + 1].url()) : resource->resourceRequest().url();
+            bool crossOrigin = IsCrossOrigin(responses[i].url(), newURL);
+            info->addRedirect(responses[i], crossOrigin);
+        }
+
         if (resource->response().isHTTP() && resource->response().httpStatusCode() < 400) {
             populateResourceTiming(info.get(), resource);
             info->setLoadFinishTime(finishTime);
             // encodedDataLength == -1 means "not available".
             // TODO(ricea): Find cases where it is not available but the
             // PerformanceResourceTiming spec requires it to be available and
             // fix them.
             info->addFinalTransferSize(encodedDataLength == -1 ? 0 : encodedDataLength);
             if (resource->options().requestInitiatorContext == DocumentContext)
                 context().addResourceTiming(*info);
@@ skipping 142 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, int64_t encodedDataLength)
+bool ResourceFetcher::willFollowRedirect(Resource* resource, ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 {
     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) {
             RefPtr<SecurityOrigin> sourceOrigin = resource->options().securityOrigin;
             if (!sourceOrigin.get())
                 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()) {
-        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);
+        bool crossOrigin = IsCrossOrigin(redirectResponse.url(), newRequest.url());
+        it->value->addRedirect(redirectResponse, crossOrigin);
     }
     newRequest.setAllowStoredCredentials(resource->options().allowCredentials == AllowStoredCredentials);
     willSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options());
     return true;
 }
 
 void ResourceFetcher::willSendRequest(unsigned long identifier, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
 {
     context().dispatchWillSendRequest(identifier, newRequest, redirectResponse, options.initiatorInfo);
 }
@@ skipping 191 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