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 74 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 496 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);
+    double startTime = monotonicallyIncreasingTime();
+
+    // The request can already be fetched in a previous navigation. Thus
+    // startTime must be set accordingly.
+    if (resource->resourceRequest().previousNavigationStart())
+        startTime = resource->resourceRequest().previousNavigationStart();
+
+    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));
 }
 
+void ResourceFetcher::storeResourceTimingPreviousRedirects(Resource* resource)
+{
+    ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
+    if (it == m_resourceTimingInfoMap.end())
+        return;
+
+    const WebVector<WebURLResponse>& responses = resource->resourceRequest().previousResponses();
+    for (size_t i = 0; i < responses.size(); ++i) {
+        const ResourceResponse& response = responses[i].toResourceResponse();
+        const KURL& newURL = i + 1 < responses.size() ? KURL(responses[i + 1].url()) : resource->resourceRequest().url();
+        bool crossOrigin = IsCrossOrigin(response.url(), newURL);
+        it->value->addRedirect(response, crossOrigin);
+    }
+}
+
 ResourceFetcher::RevalidationPolicy ResourceFetcher::determineRevalidationPolicy(Resource::Type type, const FetchRequest& fetchRequest, Resource* existingResource, bool isStaticData) const
 {
     const ResourceRequest& request = fetchRequest.resourceRequest();
 
     if (!existingResource)
         return Load;
 
     // Checks if the resource has an explicit policy about integrity metadata.
     // Currently only applies to ScriptResources.
     //
@@ skipping 400 matching lines @@
     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);
 
     storeResourceTimingInitiatorInformation(resource);
+    storeResourceTimingPreviousRedirects(resource);
     resource->setFetcherSecurityOrigin(context().getSecurityOrigin());
     loader->start(request, context().loadingTaskRunner(), context().defersLoading());
     return true;
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader)
 {
     if (m_loaders.contains(loader))
         m_loaders.remove(loader);
     else if (m_nonBlockingLoaders.contains(loader))
@@ skipping 22 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