Report nav timing 2 instance as soon as it's requested.

third_party/WebKit/Source/platform/loader/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 635 matching lines @@
   if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
     determineRequestContext(request, type);
   if (type == Resource::LinkPrefetch)
     request.setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
 
   context().addAdditionalRequestHeaders(
       request,
       (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
+std::unique_ptr<ResourceTimingInfo> ResourceFetcher::getNavigationTimingInfo() {
+  return std::move(m_navigationTimingInfo);
+}
+
 void ResourceFetcher::initializeRevalidation(
     ResourceRequest& revalidatingRequest,
     Resource* resource) {
   DCHECK(resource);
   DCHECK(memoryCache()->contains(resource));
   DCHECK(resource->isLoaded());
   DCHECK(resource->canUseCacheValidator());
   DCHECK(!resource->isCacheValidator());
   DCHECK(!context().isControlledByServiceWorker());
 
@@ skipping 69 matching lines @@
   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);
+    m_navigationTimingInfoRef = m_navigationTimingInfo.get();
   }
 
   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::recordResourceTimingOnRedirect(
     Resource* resource,
     const ResourceResponse& redirectResponse,
     bool crossOrigin) {
   ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
   if (it != m_resourceTimingInfoMap.end()) {
     it->value->addRedirect(redirectResponse, crossOrigin);
   }
 
   if (resource->getType() == Resource::MainResource) {
-    DCHECK(m_navigationTimingInfo);
-    m_navigationTimingInfo->addRedirect(redirectResponse, crossOrigin);
+    DCHECK(m_navigationTimingInfoRef);
+    m_navigationTimingInfoRef->addRedirect(redirectResponse, crossOrigin);
   }
 }
 
 ResourceFetcher::RevalidationPolicy
 ResourceFetcher::determineRevalidationPolicy(Resource::Type type,
                                              const FetchRequest& fetchRequest,
                                              Resource* existingResource,
                                              bool isStaticData) const {
   const ResourceRequest& request = fetchRequest.resourceRequest();
 
@@ skipping 322 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::handleLoadCompletion(Resource* resource) {
   context().didLoadResource(resource);
 
   resource->reloadIfLoFiOrPlaceholderImage(this, Resource::kReloadIfNeeded);
 }
 
 void ResourceFetcher::handleLoaderFinish(Resource* resource,
                                          double finishTime,
                                          LoaderFinishType type) {
   DCHECK(resource);
 
   ResourceLoader* loader = resource->loader();
   if (type == DidFinishFirstPartInMultipart) {
     // When loading a multipart resource, make the loader non-block when
     // finishing loading the first part.
     moveResourceLoaderToNonBlocking(loader);
   } else {
     removeResourceLoader(loader);
     DCHECK(!m_nonBlockingLoaders.contains(loader));
   }
   DCHECK(!m_loaders.contains(loader));
 
   const int64_t encodedDataLength = resource->response().encodedDataLength();
 
   if (resource->getType() == Resource::MainResource) {
-    DCHECK(m_navigationTimingInfo);
+    DCHECK(m_navigationTimingInfoRef);
     // Store redirect responses that were packed inside the final response.
-    addRedirectsToTimingInfo(resource, m_navigationTimingInfo.get());
+    addRedirectsToTimingInfo(resource, m_navigationTimingInfoRef);
     if (resource->response().isHTTP()) {
-      populateTimingInfo(m_navigationTimingInfo.get(), resource);
-      m_navigationTimingInfo->addFinalTransferSize(
+      populateTimingInfo(m_navigationTimingInfoRef, resource);
+      m_navigationTimingInfoRef->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.
     addRedirectsToTimingInfo(resource, info.get());
 
     if (resource->response().isHTTP() &&
         resource->response().httpStatusCode() < 400) {
@@ skipping 363 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