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
@@ skipping 77 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);
 }
@@ skipping 68 matching lines @@
   // 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;
@@ skipping 518 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()))
@@ skipping 354 matching lines @@
   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);
@@ skipping 176 matching lines @@
 
 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) {
+    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();
 
@@ skipping 10 matching lines @@
         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,
@@ skipping 225 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