[WIP] off-main-thread loading

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/FrameView.h"
 #include "core/frame/LocalFrame.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 63 matching lines @@
   m_instrumentingAgents->removeInspectorTraceEvents(this);
   m_instrumentingAgents = nullptr;
 }
 
 DEFINE_TRACE(InspectorTraceEvents) {
   visitor->trace(m_instrumentingAgents);
   InspectorAgent::trace(visitor);
 }
 
 void InspectorTraceEvents::willSendRequest(
-    LocalFrame* frame,
     unsigned long identifier,
-    DocumentLoader*,
+    DocumentLoader* loader,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo&) {
+  LocalFrame* frame = loader ? loader->frame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorSendRequestEvent::data(identifier, frame, request));
-  probe::asyncTaskScheduled(frame->document(), "SendRequest",
+  probe::asyncTaskScheduled(frame ? frame->document() : nullptr, "SendRequest",
                             asyncId(identifier));
 }
 
 void InspectorTraceEvents::didReceiveResourceResponse(
-    LocalFrame* frame,
     unsigned long identifier,
-    DocumentLoader*,
+    DocumentLoader* loader,
     const ResourceResponse& response,
     Resource*) {
+  LocalFrame* frame = loader ? loader->frame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD,
       "data", InspectorReceiveResponseEvent::data(identifier, frame, response));
-  probe::AsyncTask asyncTask(frame->document(), asyncId(identifier),
-                             "response");
+  probe::AsyncTask asyncTask(frame ? frame->document() : nullptr,
+                             asyncId(identifier), "response");
 }
 
-void InspectorTraceEvents::didReceiveData(LocalFrame* frame,
-                                          unsigned long identifier,
+void InspectorTraceEvents::didReceiveData(unsigned long identifier,
+                                          DocumentLoader* loader,
                                           const char* data,
                                           int encodedDataLength) {
+  LocalFrame* frame = loader ? loader->frame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceReceivedData", TRACE_EVENT_SCOPE_THREAD,
       "data",
       InspectorReceiveDataEvent::data(identifier, frame, encodedDataLength));
-  probe::AsyncTask asyncTask(frame->document(), asyncId(identifier), "data");
+  probe::AsyncTask asyncTask(frame ? frame->document() : nullptr,
+                             asyncId(identifier), "data");
 }
 
-void InspectorTraceEvents::didFinishLoading(LocalFrame* frame,
-                                            unsigned long identifier,
+void InspectorTraceEvents::didFinishLoading(unsigned long identifier,
+                                            DocumentLoader* loader,
                                             double finishTime,
                                             int64_t encodedDataLength,
                                             int64_t decodedBodyLength) {
+  LocalFrame* frame = loader ? loader->frame() : nullptr;
   TRACE_EVENT_INSTANT1(
       "devtools.timeline", "ResourceFinish", TRACE_EVENT_SCOPE_THREAD, "data",
       InspectorResourceFinishEvent::data(identifier, finishTime, false,
                                          encodedDataLength, decodedBodyLength));
-  probe::AsyncTask asyncTask(frame->document(), asyncId(identifier));
+  probe::AsyncTask asyncTask(frame ? frame->document() : 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 1040 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