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 761 matching lines @@
   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));
+  else
+    m_mainResourceTimingInfoMap.add(resource->identifier(), 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::getMainResourceTimingInfo(
+    unsigned long identifier) {

[Yoav Weiss, 2016/11/22 10:26:23]

IIUC, this is only ever called with the mainResourceIdentifier(). Is that
correct?

Are there scenarios where the m_mainResourceTimingInfoMap will contain other
resources?

[sunjian, 2016/11/22 22:25:44]

Yes. For now it only gets called with mainResourceIdentifier().

As you can see from the changes in
ResourceFetcher::storeResourceTimingInitiatorInformation(...),
m_mainResourceTimingInfoMap definitely only contains main resources but not all
of them. There are main resources that are captured by resource timing but they
are not the ones that navigation timing cares about.
It's also okay when ResourceFetcher::getMainResourceTimingInfo doesn't get
called with mainResourceIdentifier() cause it will just return a nullptr if the
identifier is not pointing to a main resource.

+  MainResourceTimingInfoMap::iterator it =
+      m_mainResourceTimingInfoMap.find(identifier);
+  if (it != m_mainResourceTimingInfoMap.end()) {
+    return it->value.get();
+  }
+  return nullptr;
+}
+
 void ResourceFetcher::didFinishLoading(Resource* resource,
                                        double finishTime,
                                        int64_t encodedDataLength,
                                        DidFinishLoadingReason finishReason) {
   network_instrumentation::endResourceLoad(
       resource->identifier(), network_instrumentation::RequestOutcome::Success);
   DCHECK(resource);
 
   // 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()));
 
+  MainResourceTimingInfoMap::iterator it =
+      m_mainResourceTimingInfoMap.find(resource->identifier());
+  if (it != m_mainResourceTimingInfoMap.end()) {
+    // 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);
+      it->value->addRedirect(responses[i], crossOrigin);
+    }
+    it->value->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);
@@ skipping 245 matching lines @@
     if (resource->getType() == Resource::Image &&
         shouldDeferImageLoad(newRequest.url()))
       return false;
   }
 
   ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
   if (it != m_resourceTimingInfoMap.end()) {
     bool crossOrigin = IsCrossOrigin(redirectResponse.url(), newRequest.url());
     it->value->addRedirect(redirectResponse, crossOrigin);
   }
+  MainResourceTimingInfoMap::iterator itt =
+      m_mainResourceTimingInfoMap.find(resource->identifier());
+  if (itt != m_mainResourceTimingInfoMap.end()) {
+    bool crossOrigin = IsCrossOrigin(redirectResponse.url(), newRequest.url());
+    itt->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,
@@ 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