Add trace event for complete network request

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 24 matching lines @@
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoadingLog.h"
 #include "core/fetch/UniqueIdentifier.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/mhtml/ArchiveResource.h"
 #include "platform/mhtml/MHTMLArchive.h"
 #include "platform/network/NetworkUtils.h"
 #include "platform/network/ResourceTimingInfo.h"
+#include "platform/tracing/NetworkInstrumentation.h"
 #include "platform/tracing/TraceEvent.h"
 #include "platform/tracing/TracedValue.h"
 #include "platform/weborigin/KnownPorts.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/text/CString.h"
@@ skipping 435 matching lines @@
          factory.type() == Resource::XSLStyleSheet);
 
   context().populateRequestData(request.mutableResourceRequest());
   if (request.resourceRequest().httpHeaderField("Upgrade-Insecure-Requests") !=
       AtomicString("1")) {
     context().modifyRequestForCSP(request.mutableResourceRequest());
   }
   context().addClientHintsIfNecessary(request);
   context().addCSPHeaderIfNecessary(factory.type(), request);
 
   TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",

[chiniforooshan, 2016/10/24 19:25:36]

Please create a bug and add a TODO here, referencing the bug, to eventually
delete these events now that we are introducing network_instrumentation. Please
add the TODO in other similar locations in this file, too (i.e. for blink.net
events).

[dproy, 2016/11/03 15:13:37]

Done.

                urlForTraceEvent(request.url()));
 
   if (!request.url().isValid())
     return nullptr;
 
   unsigned long identifier = createUniqueIdentifier();
+  network_instrumentation::beginResourceLoad(
+      identifier, request.url().getString().utf8().data());

[chiniforooshan, 2016/10/24 19:25:36]

Do you think we can move this (and the line before in which an id is created) to
the beginning of the function, right after the UMA update?

[caseq, 2016/10/24 22:47:46]

Do we really need it in the same place? I think it's important that it's _after_
the bail out -- otherwise we would have to take care of properly terminating the
event. I'd actually consider moving it down to actual start load, considering
the amount of bail outs here.

Also, let's pass blink strings as they are to the instrumentation call -- or
maybe just pass the entire request?

[Yoav Weiss, 2016/10/25 04:46:46]

I think it's important to be able to instrument this particular function, as
it's known to be fairly expensive.
Starting the instrumentation at the start load would ignore that.

[chiniforooshan, 2016/10/25 18:00:40]

Good point about terminating the event! Can we deal with that by making
BeginResourceLoad a scoped object that closes the event in its destructor if we
don't tell it otherwise, i.e. when a resource request is actually going to be
sent? IMO it's better to cover the logic in this function; people may be
specially interested in memcache stuff?

[dproy, 2016/11/03 15:13:37]

I added a scoped tracker. Does the overhead look reasonable?

   request.mutableResourceRequest().setPriority(computeLoadPriority(
       factory.type(), request, ResourcePriority::NotVisible));
   initializeResourceRequest(request.mutableResourceRequest(), factory.type(),
                             request.defer());
 
   if (!context().canRequest(
           factory.type(), request.resourceRequest(),
           MemoryCache::removeFragmentIdentifierIfNeeded(request.url()),
           request.options(), request.forPreload(),
           request.getOriginRestriction())) {
@@ skipping 595 matching lines @@
     return nullptr;
   m_archive = MHTMLArchive::create(resource->url(), resource->resourceBuffer());
   return m_archive ? m_archive->mainResource() : nullptr;
 }
 
 void ResourceFetcher::didFinishLoading(Resource* resource,
                                        double finishTime,
                                        int64_t encodedDataLength,
                                        DidFinishLoadingReason finishReason) {
   TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource->identifier());
+  network_instrumentation::endResourceLoad(resource->identifier());
   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 ||
@@ skipping 30 matching lines @@
   context().dispatchDidFinishLoading(resource->identifier(), finishTime,
                                      encodedDataLength);
   if (finishReason == DidFinishLoading)
     resource->finish(finishTime);
   context().didLoadResource(resource);
 }
 
 void ResourceFetcher::didFailLoading(Resource* resource,
                                      const ResourceError& error) {
   TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource->identifier());
+  network_instrumentation::endResourceLoad(resource->identifier());

[caseq, 2016/10/24 22:47:46]

let's also pass success / fail flag down to the instrumentation method.

[dproy, 2016/11/03 15:13:37]

Done.

   removeResourceLoader(resource->loader());
   m_resourceTimingInfoMap.take(const_cast<Resource*>(resource));
   bool isInternalRequest = resource->options().initiatorInfo.name ==
                            FetchInitiatorTypeNames::internal;
   context().dispatchDidFail(resource->identifier(), error, isInternalRequest);
   resource->error(error);
   context().didLoadResource(resource);
 }
 
 void ResourceFetcher::didReceiveResponse(Resource* resource,
@@ skipping 430 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