DevTools: Move network request instrumentation points for timeline down the stack.

third_party/WebKit/Source/platform/loader/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 11 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/loader/fetch/ResourceLoader.h"
 
+#include <memory>
 #include "platform/SharedBuffer.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/exported/WrappedResourceResponse.h"
+#include "platform/instrumentation/inspector/PlatformInspectorTraceEvents.h"
 #include "platform/loader/fetch/CrossOriginAccessControl.h"
 #include "platform/loader/fetch/FetchContext.h"
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/network/NetworkInstrumentation.h"
 #include "platform/network/ResourceError.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 #include "wtf/Assertions.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
-#include <memory>
 
 namespace blink {
 
 ResourceLoader* ResourceLoader::create(ResourceFetcher* fetcher,
                                        Resource* resource) {
   return new ResourceLoader(fetcher, resource);
 }
 
 ResourceLoader::ResourceLoader(ResourceFetcher* fetcher, Resource* resource)
     : m_fetcher(fetcher),
@@ skipping 302 matching lines @@
   } else if (m_resource->options().corsEnabled == IsCORSEnabled) {
     ResourceRequestBlockedReason blockedReason =
         canAccessResponse(m_resource, response);
     if (blockedReason != ResourceRequestBlockedReason::None) {
       handleError(ResourceError::cancelledDueToAccessCheckError(response.url(),
                                                                 blockedReason));
       return;
     }
   }
 
+  TRACE_EVENT1(
+      "devtools.timeline", "ResourceReceiveResponse", "data",
+      InspectorReceiveResponseEvent::data(m_resource->identifier(), response));
+
   context().dispatchDidReceiveResponse(
       m_resource->identifier(), response,
       m_resource->resourceRequest().frameType(),
       m_resource->resourceRequest().requestContext(), m_resource);
 
   m_resource->responseReceived(response, std::move(handle));
   if (!m_resource->loader())
     return;
 
   if (response.httpStatusCode() >= 400 &&
       !m_resource->shouldIgnoreHTTPStatusCodeErrors())
     handleError(ResourceError::cancelledError(response.url()));
 }
 
 void ResourceLoader::didReceiveResponse(const WebURLResponse& response) {
   didReceiveResponse(response, nullptr);
 }
 
 void ResourceLoader::didDownloadData(int length, int encodedDataLength) {
+  TRACE_EVENT1("devtools.timeline", "ResourceReceivedData", "data",
+               InspectorReceiveDataEvent::data(m_resource->identifier(),
+                                               encodedDataLength));
   context().dispatchDidDownloadData(m_resource->identifier(), length,
                                     encodedDataLength);
   m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didReceiveData(const char* data, int length) {
   CHECK_GE(length, 0);
 
+  TRACE_EVENT1(
+      "devtools.timeline", "ResourceReceivedData", "data",
+      InspectorReceiveDataEvent::data(m_resource->identifier(), length));
   context().dispatchDidReceiveData(m_resource->identifier(), data, length);
   m_resource->addToDecodedBodyLength(length);
   m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didReceiveTransferSizeUpdate(int transferSizeDiff) {
   DCHECK_GT(transferSizeDiff, 0);
   context().dispatchDidReceiveEncodedData(m_resource->identifier(),
                                           transferSizeDiff);
 }
 
 void ResourceLoader::didFinishLoadingFirstPartInMultipart() {
+  TRACE_EVENT1("devtools.timeline", "ResourceFinish", "data",
+               InspectorResourceFinishEvent::data(
+                   m_resource->identifier(), 0, false,
+                   m_resource->response().encodedDataLength()));
   network_instrumentation::endResourceLoad(
       m_resource->identifier(),
       network_instrumentation::RequestOutcome::Success);
 
   m_fetcher->handleLoaderFinish(m_resource.get(), 0,
                                 ResourceFetcher::DidFinishFirstPartInMultipart);
 }
 
 void ResourceLoader::didFinishLoading(double finishTime,
                                       int64_t encodedDataLength,
                                       int64_t encodedBodyLength) {
+  TRACE_EVENT1(
+      "devtools.timeline", "ResourceFinish", "data",
+      InspectorResourceFinishEvent::data(m_resource->identifier(), finishTime,
+                                         false, encodedDataLength));
   m_resource->setEncodedDataLength(encodedDataLength);
   m_resource->addToEncodedBodyLength(encodedBodyLength);
-
   m_loader.reset();
 
   network_instrumentation::endResourceLoad(
       m_resource->identifier(),
       network_instrumentation::RequestOutcome::Success);
 
   m_fetcher->handleLoaderFinish(m_resource.get(), finishTime,
                                 ResourceFetcher::DidFinishLoading);
 }
 
 void ResourceLoader::didFail(const WebURLError& error,
                              int64_t encodedDataLength,
                              int64_t encodedBodyLength) {
   m_resource->setEncodedDataLength(encodedDataLength);
   m_resource->addToEncodedBodyLength(encodedBodyLength);
   handleError(error);
 }
 
 void ResourceLoader::handleError(const ResourceError& error) {
   if (m_isCacheAwareLoadingActivated && error.isCacheMiss() &&
       context().shouldLoadNewResource(m_resource->getType())) {
     m_resource->willReloadAfterDiskCacheMiss();
     m_isCacheAwareLoadingActivated = false;
     restart(m_resource->resourceRequest());
     return;
   }
 
+  TRACE_EVENT1("devtools.timeline", "ResourceFinish", "data",
+               InspectorResourceFinishEvent::data(
+                   m_resource->identifier(), 0, true,
+                   m_resource->response().encodedDataLength()));
   m_loader.reset();
 
   network_instrumentation::endResourceLoad(
       m_resource->identifier(), network_instrumentation::RequestOutcome::Fail);
 
   m_fetcher->handleLoaderError(m_resource.get(), error);
 }
 
 void ResourceLoader::requestSynchronously(const ResourceRequest& request) {
   // downloadToFile is not supported for synchronous requests.
@@ skipping 57 matching lines @@
     return;
 
   // Don't activate if cache policy is explicitly set.
   if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
     return;
 
   m_isCacheAwareLoadingActivated = true;
 }
 
 }  // namespace blink