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 294 matching lines @@
         request.resourceRequest().requestContext());
   }
 
   if (isStaticData)
     return;
 
   if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() &&
       !m_validatedURLs.contains(request.resourceRequest().url())) {
     // Resources loaded from memory cache should be reported the first time
     // they're used.
-    std::unique_ptr<ResourceTimingInfo> info = ResourceTimingInfo::create(
+    RefPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(
         request.options().initiatorInfo.name, monotonicallyIncreasingTime(),
         resource->getType() == Resource::MainResource);
     populateTimingInfo(info.get(), resource);
     info->clearLoadTimings();
     info->setLoadFinishTime(info->initialTime());
-    m_scheduledResourceTimingReports.push_back(std::move(info));
+    m_scheduledResourceTimingReports.push_back(info.release());
     if (!m_resourceTimingReportTimer.isActive())
       m_resourceTimingReportTimer.startOneShot(0, BLINK_FROM_HERE);
   }
 
   if (m_validatedURLs.size() >= kMaxValidatedURLsSize) {
     m_validatedURLs.clear();
   }
   m_validatedURLs.insert(request.resourceRequest().url());
 }
 
@@ skipping 292 matching lines @@
     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;
+  Vector<RefPtr<ResourceTimingInfo>> timingReports;
   timingReports.swap(m_scheduledResourceTimingReports);
   for (const auto& timingInfo : timingReports)
     context().addResourceTiming(*timingInfo);
 }
 
 void ResourceFetcher::determineRequestContext(ResourceRequest& request,
                                               Resource::Type type,
                                               bool isMainFrame) {
   WebURLRequest::RequestContext requestContext =
       requestContextFromType(isMainFrame, type);
@@ skipping 16 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);
 }
 
+ResourceTimingInfo* ResourceFetcher::getNavigationTimingInfo() {
+  return m_navigationTimingInfo.get();
+}
+
 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 71 matching lines @@
                          : 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 =
+  RefPtr<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 ||
@@ skipping 348 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);
@@ skipping 14 matching lines @@
   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()) {
       populateTimingInfo(m_navigationTimingInfo.get(), resource);
       m_navigationTimingInfo->addFinalTransferSize(
           encodedDataLength == -1 ? 0 : encodedDataLength);
     }
   }
-  if (std::unique_ptr<ResourceTimingInfo> info =
+  if (RefPtr<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) {
       populateTimingInfo(info.get(), resource);
       info->setLoadFinishTime(finishTime);
       // encodedDataLength == -1 means "not available".
       // TODO(ricea): Find cases where it is not available but the
@@ skipping 360 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