Support DevTools for off-main-thread-fetch

third_party/WebKit/Source/core/inspector/InspectorTraceEvents.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/inspector/InspectorTraceEvents.h"
 
 #include <inttypes.h>
 
 #include <memory>
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "core/animation/Animation.h"
 #include "core/animation/KeyframeEffectReadOnly.h"
 #include "core/css/invalidation/InvalidationSet.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutObject.h"
+#include "core/loader/DocumentLoader.h"
 #include "core/loader/resource/CSSStyleSheetResource.h"
 #include "core/page/Page.h"
 #include "core/paint/PaintLayer.h"
 #include "core/probe/CoreProbes.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerThread.h"
 #include "core/xmlhttprequest/XMLHttpRequest.h"
 #include "platform/InstanceCounters.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/instrumentation/tracing/TracedValue.h"
@@ skipping 64 matching lines @@
   instrumenting_agents_->removeInspectorTraceEvents(this);
   instrumenting_agents_ = nullptr;
 }
 
 DEFINE_TRACE(InspectorTraceEvents) {
   visitor->Trace(instrumenting_agents_);
   InspectorAgent::Trace(visitor);
 }
 
 void InspectorTraceEvents::WillSendRequest(
-    LocalFrame* frame,
+    ExecutionContext*,
     unsigned long identifier,
-    DocumentLoader*,
+    DocumentLoader* loader,
     ResourceRequest& request,
     const ResourceResponse& redirect_response,
     const FetchInitiatorInfo&) {
+  LocalFrame* frame = loader ? loader->GetFrame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorSendRequestEvent::Data(identifier, frame, request));
-  probe::AsyncTaskScheduled(frame->GetDocument(), "SendRequest",
-                            AsyncId(identifier));
+  probe::AsyncTaskScheduled(frame ? frame->GetDocument() : nullptr,
+                            "SendRequest", AsyncId(identifier));
 }
 
 void InspectorTraceEvents::DidReceiveResourceResponse(
-    LocalFrame* frame,
     unsigned long identifier,
-    DocumentLoader*,
+    DocumentLoader* loader,
     const ResourceResponse& response,
     Resource*) {
+  LocalFrame* frame = loader ? loader->GetFrame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorReceiveResponseEvent::Data(identifier, frame, response));
-  probe::AsyncTask async_task(frame->GetDocument(), AsyncId(identifier),
-                              "response");
+  probe::AsyncTask async_task(frame ? frame->GetDocument() : nullptr,
+                              AsyncId(identifier), "response");
 }
 
-void InspectorTraceEvents::DidReceiveData(LocalFrame* frame,
-                                          unsigned long identifier,
+void InspectorTraceEvents::DidReceiveData(unsigned long identifier,
+                                          DocumentLoader* loader,
                                           const char* data,
                                           int encoded_data_length) {
+  LocalFrame* frame = loader ? loader->GetFrame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceReceivedData", TRACE_EVENT_SCOPE_THREAD,
       "data",
       InspectorReceiveDataEvent::Data(identifier, frame, encoded_data_length));
-  probe::AsyncTask async_task(frame->GetDocument(), AsyncId(identifier),
-                              "data");
+  probe::AsyncTask async_task(frame ? frame->GetDocument() : nullptr,
+                              AsyncId(identifier), "data");
 }
 
-void InspectorTraceEvents::DidFinishLoading(LocalFrame* frame,
-                                            unsigned long identifier,
+void InspectorTraceEvents::DidFinishLoading(unsigned long identifier,
+                                            DocumentLoader* loader,
                                             double finish_time,
                                             int64_t encoded_data_length,
                                             int64_t decoded_body_length) {
+  LocalFrame* frame = loader ? loader->GetFrame() : nullptr;
   TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceFinish",
                        TRACE_EVENT_SCOPE_THREAD, "data",
                        InspectorResourceFinishEvent::Data(
                            identifier, finish_time, false, encoded_data_length,
                            decoded_body_length));
-  probe::AsyncTask async_task(frame->GetDocument(), AsyncId(identifier));
+  probe::AsyncTask async_task(frame ? frame->GetDocument() : nullptr,
+                              AsyncId(identifier));
 }
 
 void InspectorTraceEvents::DidFailLoading(unsigned long identifier,
                                           const ResourceError&) {
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceFinish", TRACE_EVENT_SCOPE_THREAD, "data",
       InspectorResourceFinishEvent::Data(identifier, 0, true, 0, 0));
 }
 
 void InspectorTraceEvents::Will(const probe::ExecuteScript&) {}
@@ skipping 1055 matching lines @@
   return value;
 }
 
 std::unique_ptr<TracedValue> InspectorAsyncTask::Data(const String& name) {
   std::unique_ptr<TracedValue> value = TracedValue::Create();
   value->SetString("name", name);
   return value;
 }
 
 }  // namespace blink