transferSize implementation

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 85 matching lines @@
     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());
 }
 
+void addRedirectsToTimingInfo(Resource* resource, ResourceTimingInfo* info) {
+  // Store redirect responses that were packed inside the final response.
+  const auto& 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);
+  }
+}
+
 }  // 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 474 matching lines @@
       resource = createResourceForLoading(request, request.charset(), factory);
       break;
     case Revalidate:
       initializeRevalidation(request.mutableResourceRequest(), resource);
       break;
     case Use:
       if (resource->isLinkPreload() && !request.isLinkPreload())
         resource->setLinkPreload(false);
       break;
   }
-
   if (!resource)
     return nullptr;
   if (resource->getType() != factory.type()) {
     DCHECK(request.forPreload());
     return nullptr;
   }
 
   if (!resource->isAlive())
     m_deadStatsRecorder.update(policy);
 
@@ skipping 23 matching lines @@
 
   // Returns with an existing resource if the resource does not need to start
   // loading immediately. If revalidation policy was determined as |Revalidate|,
   // the resource was already initialized for the revalidation here, but won't
   // start loading.
   if (!resourceNeedsLoad(resource, request, policy))
     return resource;
 
   if (!startLoad(resource))
     return nullptr;
-
   scopedResourceLoadTracker.resourceLoadContinuesBeyondScope();
 
   DCHECK(!resource->errorOccurred() ||
          request.options().synchronousPolicy == RequestSynchronously);
   return resource;
 }
 
 void ResourceFetcher::resourceTimingReportTimerFired(TimerBase* timer) {
   DCHECK_EQ(timer, &m_resourceTimingReportTimer);
   Vector<std::unique_ptr<ResourceTimingInfo>> timingReports;
@@ skipping 95 matching lines @@
 
   // - Don't add main resource to cache to prevent reuse.
   // - Don't add the resource if its body will not be stored.
   if (factory.type() != Resource::MainResource &&
       request.options().dataBufferingPolicy != DoNotBufferData) {
     memoryCache()->add(resource);
   }
   return resource;
 }
 
-void ResourceFetcher::storeResourceTimingInitiatorInformation(
+void ResourceFetcher::storePerformanceTimingInitiatorInformation(
     Resource* resource) {
   const AtomicString& fetchInitiator = resource->options().initiatorInfo.name;
   if (fetchInitiator == FetchInitiatorTypeNames::internal)
     return;
 
   bool isMainResource = resource->getType() == Resource::MainResource;
 
   // 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();
 
+  // This buffer is created and populated for providing transferSize
+  // and redirect timing opt-in information.
+  if (isMainResource) {
+    DCHECK(!m_navigationTimingInfo);
+    m_navigationTimingInfo =
+        ResourceTimingInfo::create(fetchInitiator, startTime, isMainResource);
+  }
+
   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()))
+      context().updateTimingInfoForIFrameNavigation(info.get())) {
     m_resourceTimingInfoMap.add(resource, std::move(info));
+  }
 }
 
 ResourceFetcher::RevalidationPolicy
 ResourceFetcher::determineRevalidationPolicy(Resource::Type type,
                                              const FetchRequest& fetchRequest,
                                              Resource* existingResource,
                                              bool isStaticData) const {
   const ResourceRequest& request = fetchRequest.resourceRequest();
 
   if (!existingResource)
@@ skipping 321 matching lines @@
 }
 
 ArchiveResource* ResourceFetcher::createArchive(Resource* resource) {
   // Only the top-frame can load MHTML.
   if (!context().isMainFrame())
     return nullptr;
   m_archive = MHTMLArchive::create(resource->url(), resource->resourceBuffer());
   return m_archive ? m_archive->mainResource() : nullptr;
 }
 
+ResourceTimingInfo* ResourceFetcher::getNavigationTimingInfo() {
+  return m_navigationTimingInfo.get();
+}
+
 void ResourceFetcher::didFinishLoading(Resource* resource,
                                        double finishTime,
                                        DidFinishLoadingReason finishReason) {
   network_instrumentation::endResourceLoad(
       resource->identifier(), network_instrumentation::RequestOutcome::Success);
   DCHECK(resource);
   const int64_t encodedDataLength = resource->response().encodedDataLength();
 
   // 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 (resource->getType() == Resource::MainResource) {
+    DCHECK(m_navigationTimingInfo);
+    // Store redirect responses that were packed inside the final response.
+    addRedirectsToTimingInfo(resource, m_navigationTimingInfo.get());
+    if (resource->response().isHTTP()) {
+      m_navigationTimingInfo->addFinalTransferSize(
+          encodedDataLength == -1 ? 0 : encodedDataLength);
+    }
+  }
   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);
-    }
+    addRedirectsToTimingInfo(resource, info.get());
 
     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
@@ skipping 151 matching lines @@
   SecurityOrigin* sourceOrigin = context().getSecurityOrigin();
   if (sourceOrigin && sourceOrigin->hasSuborigin())
     request.setSkipServiceWorker(WebURLRequest::SkipServiceWorker::All);
 
   ResourceLoader* loader = ResourceLoader::create(this, resource);
   if (resource->shouldBlockLoadEvent())
     m_loaders.add(loader);
   else
     m_nonBlockingLoaders.add(loader);
 
-  storeResourceTimingInitiatorInformation(resource);
+  storePerformanceTimingInitiatorInformation(resource);
   resource->setFetcherSecurityOrigin(sourceOrigin);
 
   loader->activateCacheAwareLoadingIfNeeded(request);
   loader->start(request, context().loadingTaskRunner(),
                 context().defersLoading());
   return true;
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader) {
   DCHECK(loader);
@@ skipping 72 matching lines @@
         shouldDeferImageLoad(newRequest.url())) {
       return ResourceRequestBlockedReason::Other;
     }
   }
 
   ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
   if (it != m_resourceTimingInfoMap.end()) {
     bool crossOrigin = IsCrossOrigin(redirectResponse.url(), newRequest.url());
     it->value->addRedirect(redirectResponse, crossOrigin);
   }
+
+  if (resource->getType() == Resource::MainResource) {
+    DCHECK(m_navigationTimingInfo);
+    bool crossOrigin = IsCrossOrigin(redirectResponse.url(), newRequest.url());
+    m_navigationTimingInfo->addRedirect(redirectResponse, crossOrigin);
+  }
+
   newRequest.setAllowStoredCredentials(resource->options().allowCredentials ==
                                        AllowStoredCredentials);
   willSendRequest(resource->identifier(), newRequest, redirectResponse,
                   resource->options());
   return ResourceRequestBlockedReason::None;
 }
 
 void ResourceFetcher::willSendRequest(unsigned long identifier,
                                       ResourceRequest& newRequest,
                                       const ResourceResponse& redirectResponse,
@@ skipping 242 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