src/third_party/WebKit/Source/core/inspector/InspectorTimelineAgent.cpp

   1 /*
   2 * Copyright (C) 2013 Google Inc. All rights reserved.
   3 *
   4 * Redistribution and use in source and binary forms, with or without
   5 * modification, are permitted provided that the following conditions are
   6 * met:
   7 *
   8 *     * Redistributions of source code must retain the above copyright
   9 * notice, this list of conditions and the following disclaimer.
  10 *     * Redistributions in binary form must reproduce the above
  11 * copyright notice, this list of conditions and the following disclaimer
  12 * in the documentation and/or other materials provided with the
  13 * distribution.
  14 *     * Neither the name of Google Inc. nor the names of its
  15 * contributors may be used to endorse or promote products derived from
  16 * this software without specific prior written permission.
  17 *
  18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #include "config.h"
  32 #include "core/inspector/InspectorTimelineAgent.h"
  33
  34 #include "core/events/Event.h"
  35 #include "core/frame/DOMWindow.h"
  36 #include "core/frame/FrameConsole.h"
  37 #include "core/frame/FrameHost.h"
  38 #include "core/frame/FrameView.h"
  39 #include "core/frame/LocalFrame.h"
  40 #include "core/inspector/IdentifiersFactory.h"
  41 #include "core/inspector/InspectorClient.h"
  42 #include "core/inspector/InspectorCounters.h"
  43 #include "core/inspector/InspectorInstrumentation.h"
  44 #include "core/inspector/InspectorLayerTreeAgent.h"
  45 #include "core/inspector/InspectorNodeIds.h"
  46 #include "core/inspector/InspectorOverlay.h"
  47 #include "core/inspector/InspectorPageAgent.h"
  48 #include "core/inspector/InspectorState.h"
  49 #include "core/inspector/InstrumentingAgents.h"
  50 #include "core/inspector/ScriptCallStack.h"
  51 #include "core/inspector/TimelineRecordFactory.h"
  52 #include "core/inspector/TraceEventDispatcher.h"
  53 #include "core/loader/DocumentLoader.h"
  54 #include "core/page/Page.h"
  55 #include "core/rendering/RenderObject.h"
  56 #include "core/rendering/RenderView.h"
  57 #include "core/xml/XMLHttpRequest.h"
  58 #include "platform/TraceEvent.h"
  59 #include "platform/graphics/DeferredImageDecoder.h"
  60 #include "platform/graphics/GraphicsLayer.h"
  61 #include "platform/network/ResourceRequest.h"
  62 #include "wtf/CurrentTime.h"
  63 #include "wtf/DateMath.h"
  64
  65 namespace WebCore {
  66
  67 namespace TimelineAgentState {
  68 static const char enabled[] = "enabled";
  69 static const char started[] = "started";
  70 static const char startedFromProtocol[] = "startedFromProtocol";
  71 static const char timelineMaxCallStackDepth[] = "timelineMaxCallStackDepth";
  72 static const char includeCounters[] = "includeCounters";
  73 static const char includeGPUEvents[] = "includeGPUEvents";
  74 static const char bufferEvents[] = "bufferEvents";
  75 static const char liveEvents[] = "liveEvents";
  76 }
  77
  78 // Must be kept in sync with WebInspector.TimelineModel.RecordType in TimelineModel.js
  79 namespace TimelineRecordType {
  80 static const char Program[] = "Program";
  81
  82 static const char EventDispatch[] = "EventDispatch";
  83 static const char ScheduleStyleRecalculation[] = "ScheduleStyleRecalculation";
  84 static const char RecalculateStyles[] = "RecalculateStyles";
  85 static const char InvalidateLayout[] = "InvalidateLayout";
  86 static const char Layout[] = "Layout";
  87 static const char UpdateLayerTree[] = "UpdateLayerTree";
  88 static const char Paint[] = "Paint";
  89 static const char ScrollLayer[] = "ScrollLayer";
  90 static const char ResizeImage[] = "ResizeImage";
  91 static const char CompositeLayers[] = "CompositeLayers";
  92
  93 static const char ParseHTML[] = "ParseHTML";
  94
  95 static const char TimerInstall[] = "TimerInstall";
  96 static const char TimerRemove[] = "TimerRemove";
  97 static const char TimerFire[] = "TimerFire";
  98
  99 static const char EvaluateScript[] = "EvaluateScript";
 100
 101 static const char MarkLoad[] = "MarkLoad";
 102 static const char MarkDOMContent[] = "MarkDOMContent";
 103 static const char MarkFirstPaint[] = "MarkFirstPaint";
 104
 105 static const char TimeStamp[] = "TimeStamp";
 106 static const char ConsoleTime[] = "ConsoleTime";
 107
 108 static const char ResourceSendRequest[] = "ResourceSendRequest";
 109 static const char ResourceReceiveResponse[] = "ResourceReceiveResponse";
 110 static const char ResourceReceivedData[] = "ResourceReceivedData";
 111 static const char ResourceFinish[] = "ResourceFinish";
 112
 113 static const char XHRReadyStateChange[] = "XHRReadyStateChange";
 114 static const char XHRLoad[] = "XHRLoad";
 115
 116 static const char FunctionCall[] = "FunctionCall";
 117 static const char GCEvent[] = "GCEvent";
 118
 119 static const char UpdateCounters[] = "UpdateCounters";
 120
 121 static const char RequestAnimationFrame[] = "RequestAnimationFrame";
 122 static const char CancelAnimationFrame[] = "CancelAnimationFrame";
 123 static const char FireAnimationFrame[] = "FireAnimationFrame";
 124
 125 static const char WebSocketCreate[] = "WebSocketCreate";
 126 static const char WebSocketSendHandshakeRequest[] = "WebSocketSendHandshakeRequest";
 127 static const char WebSocketReceiveHandshakeResponse[] = "WebSocketReceiveHandshakeResponse";
 128 static const char WebSocketDestroy[] = "WebSocketDestroy";
 129
 130 static const char RequestMainThreadFrame[] = "RequestMainThreadFrame";
 131 static const char ActivateLayerTree[] = "ActivateLayerTree";
 132 static const char DrawFrame[] = "DrawFrame";
 133 static const char BeginFrame[] = "BeginFrame";
 134 static const char DecodeImage[] = "DecodeImage";
 135 static const char GPUTask[] = "GPUTask";
 136 static const char Rasterize[] = "Rasterize";
 137 static const char PaintSetup[] = "PaintSetup";
 138
 139 static const char EmbedderCallback[] = "EmbedderCallback";
 140 }
 141
 142 using TypeBuilder::Timeline::TimelineEvent;
 143
 144 struct TimelineRecordEntry {
 145     TimelineRecordEntry(PassRefPtr<TimelineEvent> record, PassRefPtr<JSONObject> data, PassRefPtr<TypeBuilder::Array<TimelineEvent> > children, const String& type)
 146         : record(record)
 147         , data(data)
 148         , children(children)
 149         , type(type)
 150         , skipWhenUnbalanced(false)
 151     {
 152     }
 153     RefPtr<TimelineEvent> record;
 154     RefPtr<JSONObject> data;
 155     RefPtr<TypeBuilder::Array<TimelineEvent> > children;
 156     String type;
 157     bool skipWhenUnbalanced;
 158 };
 159
 160 class TimelineRecordStack {
 161 private:
 162     struct Entry {
 163         Entry(PassRefPtr<TimelineEvent> record, const String& type)
 164             : record(record)
 165             , children(TypeBuilder::Array<TimelineEvent>::create())
 166 #ifndef NDEBUG
 167             , type(type)
 168 #endif
 169         {
 170         }
 171
 172         RefPtr<TimelineEvent> record;
 173         RefPtr<TypeBuilder::Array<TimelineEvent> > children;
 174 #ifndef NDEBUG
 175         String type;
 176 #endif
 177     };
 178
 179 public:
 180     TimelineRecordStack() : m_timelineAgent(0) { }
 181     TimelineRecordStack(InspectorTimelineAgent*);
 182
 183     void addScopedRecord(PassRefPtr<TimelineEvent> record, const String& type);
 184     void closeScopedRecord(double endTime);
 185     void addInstantRecord(PassRefPtr<TimelineEvent> record);
 186
 187 #ifndef NDEBUG
 188     bool isOpenRecordOfType(const String& type);
 189 #endif
 190
 191 private:
 192     void send(PassRefPtr<JSONObject>);
 193
 194     InspectorTimelineAgent* m_timelineAgent;
 195     Vector<Entry> m_stack;
 196 };
 197
 198 struct TimelineThreadState {
 199     TimelineThreadState() { }
 200
 201     TimelineThreadState(InspectorTimelineAgent* timelineAgent)
 202         : recordStack(timelineAgent)
 203         , inKnownLayerTask(false)
 204         , decodedPixelRefId(0)
 205     {
 206     }
 207
 208     TimelineRecordStack recordStack;
 209     bool inKnownLayerTask;
 210     unsigned long long decodedPixelRefId;
 211 };
 212
 213 struct TimelineImageInfo {
 214     int backendNodeId;
 215     String url;
 216
 217     TimelineImageInfo() : backendNodeId(0) { }
 218     TimelineImageInfo(int backendNodeId, String url) : backendNodeId(backendNodeId), url(url) { }
 219 };
 220
 221 static LocalFrame* frameForExecutionContext(ExecutionContext* context)
 222 {
 223     LocalFrame* frame = 0;
 224     if (context->isDocument())
 225         frame = toDocument(context)->frame();
 226     return frame;
 227 }
 228
 229 static bool eventHasListeners(const AtomicString& eventType, DOMWindow* window, Node* node, const EventPath& eventPath)
 230 {
 231     if (window && window->hasEventListeners(eventType))
 232         return true;
 233
 234     if (node->hasEventListeners(eventType))
 235         return true;
 236
 237     for (size_t i = 0; i < eventPath.size(); i++) {
 238         if (eventPath[i].node()->hasEventListeners(eventType))
 239             return true;
 240     }
 241
 242     return false;
 243 }
 244
 245 void InspectorTimelineAgent::didGC(double startTime, double endTime, size_t collectedBytesCount)
 246 {
 247     RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(
 248         startTime * msPerSecond,
 249         0,
 250         TimelineRecordType::GCEvent,
 251         TimelineRecordFactory::createGCEventData(collectedBytesCount));
 252     record->setEndTime(endTime * msPerSecond);
 253     double time = timestamp();
 254     addRecordToTimeline(record.release(), time);
 255     if (m_state->getBoolean(TimelineAgentState::includeCounters)) {
 256         addRecordToTimeline(createCountersUpdate(), time);
 257     }
 258 }
 259
 260 InspectorTimelineAgent::~InspectorTimelineAgent()
 261 {
 262 }
 263
 264 void InspectorTimelineAgent::setFrontend(InspectorFrontend* frontend)
 265 {
 266     m_frontend = frontend->timeline();
 267 }
 268
 269 void InspectorTimelineAgent::clearFrontend()
 270 {
 271     ErrorString error;
 272     RefPtr<TypeBuilder::Array<TimelineEvent> > events;
 273     stop(&error, events);
 274     disable(&error);
 275     m_frontend = 0;
 276 }
 277
 278 void InspectorTimelineAgent::restore()
 279 {
 280     if (m_state->getBoolean(TimelineAgentState::startedFromProtocol)) {
 281         if (m_state->getBoolean(TimelineAgentState::bufferEvents))
 282             m_bufferedEvents = TypeBuilder::Array<TimelineEvent>::create();
 283
 284         setLiveEvents(m_state->getString(TimelineAgentState::liveEvents));
 285         innerStart();
 286     } else if (isStarted()) {
 287         // Timeline was started from console.timeline, it is not restored.
 288         // Tell front-end timline is no longer collecting.
 289         m_state->setBoolean(TimelineAgentState::started, false);
 290         bool fromConsole = true;
 291         m_frontend->stopped(&fromConsole);
 292     }
 293 }
 294
 295 void InspectorTimelineAgent::enable(ErrorString*)
 296 {
 297     m_state->setBoolean(TimelineAgentState::enabled, true);
 298 }
 299
 300 void InspectorTimelineAgent::disable(ErrorString*)
 301 {
 302     m_state->setBoolean(TimelineAgentState::enabled, false);
 303 }
 304
 305 void InspectorTimelineAgent::start(ErrorString* errorString, const int* maxCallStackDepth, const bool* bufferEvents, const String* liveEvents, const bool* includeCounters, const bool* includeGPUEvents)
 306 {
 307     if (!m_frontend)
 308         return;
 309     m_state->setBoolean(TimelineAgentState::startedFromProtocol, true);
 310
 311     if (isStarted()) {
 312         *errorString = "Timeline is already started";
 313         return;
 314     }
 315
 316     if (maxCallStackDepth && *maxCallStackDepth >= 0)
 317         m_maxCallStackDepth = *maxCallStackDepth;
 318     else
 319         m_maxCallStackDepth = 5;
 320
 321     if (bufferEvents && *bufferEvents) {
 322         m_bufferedEvents = TypeBuilder::Array<TimelineEvent>::create();
 323         m_lastProgressTimestamp = timestamp();
 324     }
 325
 326     if (liveEvents)
 327         setLiveEvents(*liveEvents);
 328
 329     m_state->setLong(TimelineAgentState::timelineMaxCallStackDepth, m_maxCallStackDepth);
 330     m_state->setBoolean(TimelineAgentState::includeCounters, includeCounters && *includeCounters);
 331     m_state->setBoolean(TimelineAgentState::includeGPUEvents, includeGPUEvents && *includeGPUEvents);
 332     m_state->setBoolean(TimelineAgentState::bufferEvents, bufferEvents && *bufferEvents);
 333     m_state->setString(TimelineAgentState::liveEvents, liveEvents ? *liveEvents : "");
 334
 335     innerStart();
 336     bool fromConsole = false;
 337     m_frontend->started(&fromConsole);
 338 }
 339
 340 bool InspectorTimelineAgent::isStarted()
 341 {
 342     return m_state->getBoolean(TimelineAgentState::started);
 343 }
 344
 345 void InspectorTimelineAgent::innerStart()
 346 {
 347     if (m_overlay)
 348         m_overlay->startedRecordingProfile();
 349     m_state->setBoolean(TimelineAgentState::started, true);
 350     m_instrumentingAgents->setInspectorTimelineAgent(this);
 351     ScriptGCEvent::addEventListener(this);
 352     if (m_client) {
 353         TraceEventDispatcher* dispatcher = TraceEventDispatcher::instance();
 354         dispatcher->addListener(InstrumentationEvents::BeginFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onBeginImplSideFrame, m_client);
 355         dispatcher->addListener(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onPaintSetupBegin, m_client);
 356         dispatcher->addListener(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onPaintSetupEnd, m_client);
 357         dispatcher->addListener(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onRasterTaskBegin, m_client);
 358         dispatcher->addListener(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onRasterTaskEnd, m_client);
 359         dispatcher->addListener(InstrumentationEvents::Layer, TRACE_EVENT_PHASE_DELETE_OBJECT, this, &InspectorTimelineAgent::onLayerDeleted, m_client);
 360         dispatcher->addListener(InstrumentationEvents::RequestMainThreadFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onRequestMainThreadFrame, m_client);
 361         dispatcher->addListener(InstrumentationEvents::ActivateLayerTree, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onActivateLayerTree, m_client);
 362         dispatcher->addListener(InstrumentationEvents::DrawFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onDrawFrame, m_client);
 363         dispatcher->addListener(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onImageDecodeBegin, m_client);
 364         dispatcher->addListener(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onImageDecodeEnd, m_client);
 365         dispatcher->addListener(PlatformInstrumentation::DrawLazyPixelRefEvent, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onDrawLazyPixelRef, m_client);
 366         dispatcher->addListener(PlatformInstrumentation::DecodeLazyPixelRefEvent, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onDecodeLazyPixelRefBegin, m_client);
 367         dispatcher->addListener(PlatformInstrumentation::DecodeLazyPixelRefEvent, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onDecodeLazyPixelRefEnd, m_client);
 368         dispatcher->addListener(PlatformInstrumentation::LazyPixelRef, TRACE_EVENT_PHASE_DELETE_OBJECT, this, &InspectorTimelineAgent::onLazyPixelRefDeleted, m_client);
 369         dispatcher->addListener(InstrumentationEvents::EmbedderCallback, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onEmbedderCallbackBegin, m_client);
 370         dispatcher->addListener(InstrumentationEvents::EmbedderCallback, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onEmbedderCallbackEnd, m_client);
 371
 372         if (m_state->getBoolean(TimelineAgentState::includeGPUEvents)) {
 373             m_pendingGPURecord.clear();
 374             m_client->startGPUEventsRecording();
 375         }
 376     }
 377 }
 378
 379 void InspectorTimelineAgent::stop(ErrorString* errorString, RefPtr<TypeBuilder::Array<TimelineEvent> >& events)
 380 {
 381     m_state->setBoolean(TimelineAgentState::startedFromProtocol, false);
 382     m_state->setBoolean(TimelineAgentState::bufferEvents, false);
 383     m_state->setString(TimelineAgentState::liveEvents, "");
 384
 385     if (!isStarted()) {
 386         *errorString = "Timeline was not started";
 387         return;
 388     }
 389     innerStop(false);
 390     if (m_bufferedEvents)
 391         events = m_bufferedEvents.release();
 392     m_liveEvents.clear();
 393 }
 394
 395 void InspectorTimelineAgent::innerStop(bool fromConsole)
 396 {
 397     m_state->setBoolean(TimelineAgentState::started, false);
 398
 399     if (m_client) {
 400         TraceEventDispatcher::instance()->removeAllListeners(this, m_client);
 401         if (m_state->getBoolean(TimelineAgentState::includeGPUEvents))
 402             m_client->stopGPUEventsRecording();
 403     }
 404     m_instrumentingAgents->setInspectorTimelineAgent(0);
 405     ScriptGCEvent::removeEventListener(this);
 406
 407     clearRecordStack();
 408     m_threadStates.clear();
 409     m_gpuTask.clear();
 410     m_layerToNodeMap.clear();
 411     m_pixelRefToImageInfo.clear();
 412     m_imageBeingPainted = 0;
 413     m_paintSetupStart = 0;
 414     m_mayEmitFirstPaint = false;
 415
 416     for (size_t i = 0; i < m_consoleTimelines.size(); ++i) {
 417         String message = String::format("Timeline '%s' terminated.", m_consoleTimelines[i].utf8().data());
 418         mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message);
 419     }
 420     m_consoleTimelines.clear();
 421
 422     m_frontend->stopped(&fromConsole);
 423     if (m_overlay)
 424         m_overlay->finishedRecordingProfile();
 425 }
 426
 427 void InspectorTimelineAgent::didBeginFrame(int frameId)
 428 {
 429     TraceEventDispatcher::instance()->processBackgroundEvents();
 430     m_pendingFrameRecord = TimelineRecordFactory::createGenericRecord(timestamp(), 0, TimelineRecordType::BeginFrame, TimelineRecordFactory::createFrameData(frameId));
 431 }
 432
 433 void InspectorTimelineAgent::didCancelFrame()
 434 {
 435     m_pendingFrameRecord.clear();
 436 }
 437
 438 bool InspectorTimelineAgent::willCallFunction(ExecutionContext* context, int scriptId, const String& scriptName, int scriptLine)
 439 {
 440     pushCurrentRecord(TimelineRecordFactory::createFunctionCallData(scriptId, scriptName, scriptLine), TimelineRecordType::FunctionCall, true, frameForExecutionContext(context));
 441     return true;
 442 }
 443
 444 void InspectorTimelineAgent::didCallFunction()
 445 {
 446     didCompleteCurrentRecord(TimelineRecordType::FunctionCall);
 447 }
 448
 449 bool InspectorTimelineAgent::willDispatchEvent(Document* document, const Event& event, DOMWindow* window, Node* node, const EventPath& eventPath)
 450 {
 451     if (!eventHasListeners(event.type(), window, node, eventPath))
 452         return false;
 453
 454     pushCurrentRecord(TimelineRecordFactory::createEventDispatchData(event), TimelineRecordType::EventDispatch, false, document->frame());
 455     return true;
 456 }
 457
 458 bool InspectorTimelineAgent::willDispatchEventOnWindow(const Event& event, DOMWindow* window)
 459 {
 460     if (!window->hasEventListeners(event.type()))
 461         return false;
 462     pushCurrentRecord(TimelineRecordFactory::createEventDispatchData(event), TimelineRecordType::EventDispatch, false, window->frame());
 463     return true;
 464 }
 465
 466 void InspectorTimelineAgent::didDispatchEvent()
 467 {
 468     didCompleteCurrentRecord(TimelineRecordType::EventDispatch);
 469 }
 470
 471 void InspectorTimelineAgent::didDispatchEventOnWindow()
 472 {
 473     didDispatchEvent();
 474 }
 475
 476 void InspectorTimelineAgent::didInvalidateLayout(LocalFrame* frame)
 477 {
 478     appendRecord(JSONObject::create(), TimelineRecordType::InvalidateLayout, true, frame);
 479 }
 480
 481 bool InspectorTimelineAgent::willLayout(LocalFrame* frame)
 482 {
 483     bool isPartial;
 484     unsigned needsLayoutObjects;
 485     unsigned totalObjects;
 486     frame->countObjectsNeedingLayout(needsLayoutObjects, totalObjects, isPartial);
 487
 488     pushCurrentRecord(TimelineRecordFactory::createLayoutData(needsLayoutObjects, totalObjects, isPartial), TimelineRecordType::Layout, true, frame);
 489     return true;
 490 }
 491
 492 void InspectorTimelineAgent::didLayout(RenderObject* root)
 493 {
 494     if (m_recordStack.isEmpty())
 495         return;
 496     TimelineRecordEntry& entry = m_recordStack.last();
 497     ASSERT(entry.type == TimelineRecordType::Layout);
 498     Vector<FloatQuad> quads;
 499     root->absoluteQuads(quads);
 500     if (quads.size() >= 1)
 501         TimelineRecordFactory::setLayoutRoot(entry.data.get(), quads[0], nodeId(root));
 502     else
 503         ASSERT_NOT_REACHED();
 504     didCompleteCurrentRecord(TimelineRecordType::Layout);
 505 }
 506
 507 void InspectorTimelineAgent::layerTreeDidChange()
 508 {
 509     ASSERT(!m_pendingLayerTreeData);
 510     m_pendingLayerTreeData = m_layerTreeAgent->buildLayerTree();
 511 }
 512
 513 void InspectorTimelineAgent::willUpdateLayerTree()
 514 {
 515     pushCurrentRecord(JSONObject::create(), TimelineRecordType::UpdateLayerTree, false, 0);
 516 }
 517
 518 void InspectorTimelineAgent::didUpdateLayerTree()
 519 {
 520     if (m_recordStack.isEmpty())
 521         return;
 522     TimelineRecordEntry& entry = m_recordStack.last();
 523     ASSERT(entry.type == TimelineRecordType::UpdateLayerTree);
 524     if (m_pendingLayerTreeData)
 525         TimelineRecordFactory::setLayerTreeData(entry.data.get(), m_pendingLayerTreeData.release());
 526     didCompleteCurrentRecord(TimelineRecordType::UpdateLayerTree);
 527 }
 528
 529 void InspectorTimelineAgent::didScheduleStyleRecalculation(Document* document)
 530 {
 531     appendRecord(JSONObject::create(), TimelineRecordType::ScheduleStyleRecalculation, true, document->frame());
 532 }
 533
 534 bool InspectorTimelineAgent::willRecalculateStyle(Document* document)
 535 {
 536     pushCurrentRecord(JSONObject::create(), TimelineRecordType::RecalculateStyles, true, document->frame());
 537     return true;
 538 }
 539
 540 void InspectorTimelineAgent::didRecalculateStyle(int elementCount)
 541 {
 542     if (m_recordStack.isEmpty())
 543         return;
 544     TimelineRecordEntry& entry = m_recordStack.last();
 545     ASSERT(entry.type == TimelineRecordType::RecalculateStyles);
 546     TimelineRecordFactory::setStyleRecalcDetails(entry.data.get(), elementCount);
 547     didCompleteCurrentRecord(TimelineRecordType::RecalculateStyles);
 548 }
 549
 550 void InspectorTimelineAgent::willPaint(RenderObject* renderer, const GraphicsLayer* graphicsLayer)
 551 {
 552     LocalFrame* frame = renderer->frame();
 553
 554     TraceEventDispatcher::instance()->processBackgroundEvents();
 555     double paintSetupStart = m_paintSetupStart;
 556     m_paintSetupStart = 0;
 557     if (graphicsLayer) {
 558         int layerIdentifier = graphicsLayer->platformLayer()->id();
 559         int nodeIdentifier = nodeId(renderer);
 560         ASSERT(layerIdentifier && nodeIdentifier);
 561         m_layerToNodeMap.set(layerIdentifier, nodeIdentifier);
 562         if (paintSetupStart) {
 563             RefPtr<TimelineEvent> paintSetupRecord = TimelineRecordFactory::createGenericRecord(paintSetupStart, 0, TimelineRecordType::PaintSetup, TimelineRecordFactory::createLayerData(nodeIdentifier));
 564             paintSetupRecord->setEndTime(m_paintSetupEnd);
 565             addRecordToTimeline(paintSetupRecord, paintSetupStart);
 566         }
 567     }
 568     pushCurrentRecord(JSONObject::create(), TimelineRecordType::Paint, true, frame, true);
 569 }
 570
 571 void InspectorTimelineAgent::didPaint(RenderObject* renderer, const GraphicsLayer* graphicsLayer, GraphicsContext*, const LayoutRect& clipRect)
 572 {
 573     TimelineRecordEntry& entry = m_recordStack.last();
 574     ASSERT(entry.type == TimelineRecordType::Paint);
 575     FloatQuad quad;
 576     localToPageQuad(*renderer, clipRect, &quad);
 577     int graphicsLayerId = graphicsLayer ? graphicsLayer->platformLayer()->id() : 0;
 578     TimelineRecordFactory::setPaintData(entry.data.get(), quad, nodeId(renderer), graphicsLayerId);
 579     didCompleteCurrentRecord(TimelineRecordType::Paint);
 580     if (m_mayEmitFirstPaint && !graphicsLayer) {
 581         m_mayEmitFirstPaint = false;
 582         appendRecord(JSONObject::create(), TimelineRecordType::MarkFirstPaint, false, 0);
 583     }
 584 }
 585
 586 void InspectorTimelineAgent::willPaintImage(RenderImage* renderImage)
 587 {
 588     ASSERT(!m_imageBeingPainted);
 589     m_imageBeingPainted = renderImage;
 590 }
 591
 592 void InspectorTimelineAgent::didPaintImage()
 593 {
 594     m_imageBeingPainted = 0;
 595 }
 596
 597 void InspectorTimelineAgent::willScrollLayer(RenderObject* renderer)
 598 {
 599     pushCurrentRecord(TimelineRecordFactory::createLayerData(nodeId(renderer)), TimelineRecordType::ScrollLayer, false, renderer->frame());
 600 }
 601
 602 void InspectorTimelineAgent::didScrollLayer()
 603 {
 604     didCompleteCurrentRecord(TimelineRecordType::ScrollLayer);
 605 }
 606
 607 void InspectorTimelineAgent::willDecodeImage(const String& imageType)
 608 {
 609     RefPtr<JSONObject> data = TimelineRecordFactory::createDecodeImageData(imageType);
 610     if (m_imageBeingPainted)
 611         populateImageDetails(data.get(), *m_imageBeingPainted);
 612     pushCurrentRecord(data, TimelineRecordType::DecodeImage, true, 0);
 613 }
 614
 615 void InspectorTimelineAgent::didDecodeImage()
 616 {
 617     didCompleteCurrentRecord(TimelineRecordType::DecodeImage);
 618 }
 619
 620 void InspectorTimelineAgent::willResizeImage(bool shouldCache)
 621 {
 622     RefPtr<JSONObject> data = TimelineRecordFactory::createResizeImageData(shouldCache);
 623     if (m_imageBeingPainted)
 624         populateImageDetails(data.get(), *m_imageBeingPainted);
 625     pushCurrentRecord(data, TimelineRecordType::ResizeImage, true, 0);
 626 }
 627
 628 void InspectorTimelineAgent::didResizeImage()
 629 {
 630     didCompleteCurrentRecord(TimelineRecordType::ResizeImage);
 631 }
 632
 633 void InspectorTimelineAgent::willComposite()
 634 {
 635     pushCurrentRecord(JSONObject::create(), TimelineRecordType::CompositeLayers, false, 0);
 636 }
 637
 638 void InspectorTimelineAgent::didComposite()
 639 {
 640     didCompleteCurrentRecord(TimelineRecordType::CompositeLayers);
 641     if (m_mayEmitFirstPaint) {
 642         m_mayEmitFirstPaint = false;
 643         appendRecord(JSONObject::create(), TimelineRecordType::MarkFirstPaint, false, 0);
 644     }
 645 }
 646
 647 bool InspectorTimelineAgent::willWriteHTML(Document* document, unsigned startLine)
 648 {
 649     pushCurrentRecord(TimelineRecordFactory::createParseHTMLData(startLine), TimelineRecordType::ParseHTML, true, document->frame());
 650     return true;
 651 }
 652
 653 void InspectorTimelineAgent::didWriteHTML(unsigned endLine)
 654 {
 655     if (!m_recordStack.isEmpty()) {
 656         TimelineRecordEntry& entry = m_recordStack.last();
 657         entry.data->setNumber("endLine", endLine);
 658         didCompleteCurrentRecord(TimelineRecordType::ParseHTML);
 659     }
 660 }
 661
 662 void InspectorTimelineAgent::didInstallTimer(ExecutionContext* context, int timerId, int timeout, bool singleShot)
 663 {
 664     appendRecord(TimelineRecordFactory::createTimerInstallData(timerId, timeout, singleShot), TimelineRecordType::TimerInstall, true, frameForExecutionContext(context));
 665 }
 666
 667 void InspectorTimelineAgent::didRemoveTimer(ExecutionContext* context, int timerId)
 668 {
 669     appendRecord(TimelineRecordFactory::createGenericTimerData(timerId), TimelineRecordType::TimerRemove, true, frameForExecutionContext(context));
 670 }
 671
 672 bool InspectorTimelineAgent::willFireTimer(ExecutionContext* context, int timerId)
 673 {
 674     pushCurrentRecord(TimelineRecordFactory::createGenericTimerData(timerId), TimelineRecordType::TimerFire, false, frameForExecutionContext(context));
 675     return true;
 676 }
 677
 678 void InspectorTimelineAgent::didFireTimer()
 679 {
 680     didCompleteCurrentRecord(TimelineRecordType::TimerFire);
 681 }
 682
 683 bool InspectorTimelineAgent::willDispatchXHRReadyStateChangeEvent(ExecutionContext* context, XMLHttpRequest* request)
 684 {
 685     if (!request->hasEventListeners(EventTypeNames::readystatechange))
 686         return false;
 687     pushCurrentRecord(TimelineRecordFactory::createXHRReadyStateChangeData(request->url().string(), request->readyState()), TimelineRecordType::XHRReadyStateChange, false, frameForExecutionContext(context));
 688     return true;
 689 }
 690
 691 void InspectorTimelineAgent::didDispatchXHRReadyStateChangeEvent()
 692 {
 693     didCompleteCurrentRecord(TimelineRecordType::XHRReadyStateChange);
 694 }
 695
 696 bool InspectorTimelineAgent::willDispatchXHRLoadEvent(ExecutionContext* context, XMLHttpRequest* request)
 697 {
 698     if (!request->hasEventListeners(EventTypeNames::load))
 699         return false;
 700     pushCurrentRecord(TimelineRecordFactory::createXHRLoadData(request->url().string()), TimelineRecordType::XHRLoad, true, frameForExecutionContext(context));
 701     return true;
 702 }
 703
 704 void InspectorTimelineAgent::didDispatchXHRLoadEvent()
 705 {
 706     didCompleteCurrentRecord(TimelineRecordType::XHRLoad);
 707 }
 708
 709 bool InspectorTimelineAgent::willEvaluateScript(LocalFrame* frame, const String& url, int lineNumber)
 710 {
 711     pushCurrentRecord(TimelineRecordFactory::createEvaluateScriptData(url, lineNumber), TimelineRecordType::EvaluateScript, true, frame);
 712     return true;
 713 }
 714
 715 void InspectorTimelineAgent::didEvaluateScript()
 716 {
 717     didCompleteCurrentRecord(TimelineRecordType::EvaluateScript);
 718 }
 719
 720 void InspectorTimelineAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request, const ResourceResponse&, const FetchInitiatorInfo&)
 721 {
 722     String requestId = IdentifiersFactory::requestId(identifier);
 723     appendRecord(TimelineRecordFactory::createResourceSendRequestData(requestId, request), TimelineRecordType::ResourceSendRequest, true, loader->frame());
 724 }
 725
 726 void InspectorTimelineAgent::didReceiveData(LocalFrame* frame, unsigned long identifier, const char*, int, int encodedDataLength)
 727 {
 728     String requestId = IdentifiersFactory::requestId(identifier);
 729     appendRecord(TimelineRecordFactory::createReceiveResourceData(requestId, encodedDataLength), TimelineRecordType::ResourceReceivedData, false, frame);
 730 }
 731
 732 void InspectorTimelineAgent::didReceiveResourceResponse(LocalFrame* frame, unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
 733 {
 734     String requestId = IdentifiersFactory::requestId(identifier);
 735     appendRecord(TimelineRecordFactory::createResourceReceiveResponseData(requestId, response), TimelineRecordType::ResourceReceiveResponse, false, 0);
 736 }
 737
 738 void InspectorTimelineAgent::didFinishLoadingResource(unsigned long identifier, bool didFail, double finishTime)
 739 {
 740     appendRecord(TimelineRecordFactory::createResourceFinishData(IdentifiersFactory::requestId(identifier), didFail, finishTime), TimelineRecordType::ResourceFinish, false, 0);
 741 }
 742
 743 void InspectorTimelineAgent::didFinishLoading(unsigned long identifier, DocumentLoader* loader, double monotonicFinishTime, int64_t)
 744 {
 745     didFinishLoadingResource(identifier, false, monotonicFinishTime * msPerSecond);
 746 }
 747
 748 void InspectorTimelineAgent::didFailLoading(unsigned long identifier, const ResourceError& error)
 749 {
 750     didFinishLoadingResource(identifier, true, 0);
 751 }
 752
 753 void InspectorTimelineAgent::consoleTimeStamp(ExecutionContext* context, const String& title)
 754 {
 755     appendRecord(TimelineRecordFactory::createTimeStampData(title), TimelineRecordType::TimeStamp, true, frameForExecutionContext(context));
 756 }
 757
 758 void InspectorTimelineAgent::consoleTime(ExecutionContext* context, const String& message)
 759 {
 760     pushCurrentRecord(TimelineRecordFactory::createConsoleTimeData(message), TimelineRecordType::ConsoleTime, false, frameForExecutionContext(context));
 761     m_recordStack.last().skipWhenUnbalanced = true;
 762 }
 763
 764 void InspectorTimelineAgent::consoleTimeEnd(ExecutionContext* context, const String& message, ScriptState*)
 765 {
 766     if (m_recordStack.last().type != TimelineRecordType::ConsoleTime)
 767         return;
 768     String originalMessage;
 769     if (m_recordStack.last().data->getString("message", &originalMessage) && message != originalMessage)
 770         return;
 771     // Only complete console.time that is balanced.
 772     didCompleteCurrentRecord(TimelineRecordType::ConsoleTime);
 773 }
 774
 775 void InspectorTimelineAgent::consoleTimeline(ExecutionContext* context, const String& title, ScriptState* scriptState)
 776 {
 777     if (!m_state->getBoolean(TimelineAgentState::enabled))
 778         return;
 779
 780     String message = String::format("Timeline '%s' started.", title.utf8().data());
 781     mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
 782     m_consoleTimelines.append(title);
 783     if (!isStarted()) {
 784         innerStart();
 785         bool fromConsole = true;
 786         m_frontend->started(&fromConsole);
 787     }
 788     appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeStamp, true, frameForExecutionContext(context));
 789 }
 790
 791 void InspectorTimelineAgent::consoleTimelineEnd(ExecutionContext* context, const String& title, ScriptState* scriptState)
 792 {
 793     if (!m_state->getBoolean(TimelineAgentState::enabled))
 794         return;
 795
 796     size_t index = m_consoleTimelines.find(title);
 797     if (index == kNotFound) {
 798         String message = String::format("Timeline '%s' was not started.", title.utf8().data());
 799         mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
 800         return;
 801     }
 802
 803     String message = String::format("Timeline '%s' finished.", title.utf8().data());
 804     appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeStamp, true, frameForExecutionContext(context));
 805     m_consoleTimelines.remove(index);
 806     if (!m_consoleTimelines.size() && isStarted() && !m_state->getBoolean(TimelineAgentState::startedFromProtocol)) {
 807         unwindRecordStack();
 808         innerStop(true);
 809     }
 810     mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
 811 }
 812
 813 void InspectorTimelineAgent::domContentLoadedEventFired(LocalFrame* frame)
 814 {
 815     bool isMainFrame = frame && m_pageAgent && (frame == m_pageAgent->mainFrame());
 816     appendRecord(TimelineRecordFactory::createMarkData(isMainFrame), TimelineRecordType::MarkDOMContent, false, frame);
 817     if (isMainFrame)
 818         m_mayEmitFirstPaint = true;
 819 }
 820
 821 void InspectorTimelineAgent::loadEventFired(LocalFrame* frame)
 822 {
 823     bool isMainFrame = frame && m_pageAgent && (frame == m_pageAgent->mainFrame());
 824     appendRecord(TimelineRecordFactory::createMarkData(isMainFrame), TimelineRecordType::MarkLoad, false, frame);
 825 }
 826
 827 void InspectorTimelineAgent::didCommitLoad()
 828 {
 829     clearRecordStack();
 830 }
 831
 832 void InspectorTimelineAgent::didRequestAnimationFrame(Document* document, int callbackId)
 833 {
 834     appendRecord(TimelineRecordFactory::createAnimationFrameData(callbackId), TimelineRecordType::RequestAnimationFrame, true, document->frame());
 835 }
 836
 837 void InspectorTimelineAgent::didCancelAnimationFrame(Document* document, int callbackId)
 838 {
 839     appendRecord(TimelineRecordFactory::createAnimationFrameData(callbackId), TimelineRecordType::CancelAnimationFrame, true, document->frame());
 840 }
 841
 842 bool InspectorTimelineAgent::willFireAnimationFrame(Document* document, int callbackId)
 843 {
 844     pushCurrentRecord(TimelineRecordFactory::createAnimationFrameData(callbackId), TimelineRecordType::FireAnimationFrame, false, document->frame());
 845     return true;
 846 }
 847
 848 void InspectorTimelineAgent::didFireAnimationFrame()
 849 {
 850     didCompleteCurrentRecord(TimelineRecordType::FireAnimationFrame);
 851 }
 852
 853 void InspectorTimelineAgent::willProcessTask()
 854 {
 855     pushCurrentRecord(JSONObject::create(), TimelineRecordType::Program, false, 0);
 856 }
 857
 858 void InspectorTimelineAgent::didProcessTask()
 859 {
 860     didCompleteCurrentRecord(TimelineRecordType::Program);
 861 }
 862
 863 void InspectorTimelineAgent::didCreateWebSocket(Document* document, unsigned long identifier, const KURL& url, const String& protocol)
 864 {
 865     appendRecord(TimelineRecordFactory::createWebSocketCreateData(identifier, url, protocol), TimelineRecordType::WebSocketCreate, true, document->frame());
 866 }
 867
 868 void InspectorTimelineAgent::willSendWebSocketHandshakeRequest(Document* document, unsigned long identifier, const WebSocketHandshakeRequest*)
 869 {
 870     appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketSendHandshakeRequest, true, document->frame());
 871 }
 872
 873 void InspectorTimelineAgent::didReceiveWebSocketHandshakeResponse(Document* document, unsigned long identifier, const WebSocketHandshakeRequest*, const WebSocketHandshakeResponse*)
 874 {
 875     appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketReceiveHandshakeResponse, false, document->frame());
 876 }
 877
 878 void InspectorTimelineAgent::didCloseWebSocket(Document* document, unsigned long identifier)
 879 {
 880     appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketDestroy, true, document->frame());
 881 }
 882
 883 void InspectorTimelineAgent::onBeginImplSideFrame(const TraceEventDispatcher::TraceEvent& event)
 884 {
 885     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
 886     if (layerTreeId != m_layerTreeId)
 887         return;
 888     TimelineThreadState& state = threadState(event.threadIdentifier());
 889     state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::BeginFrame, JSONObject::create()));
 890 }
 891
 892 void InspectorTimelineAgent::onPaintSetupBegin(const TraceEventDispatcher::TraceEvent& event)
 893 {
 894     ASSERT(!m_paintSetupStart);
 895     m_paintSetupStart = event.timestamp() * msPerSecond;
 896 }
 897
 898 void InspectorTimelineAgent::onPaintSetupEnd(const TraceEventDispatcher::TraceEvent& event)
 899 {
 900     ASSERT(m_paintSetupStart);
 901     m_paintSetupEnd = event.timestamp() * msPerSecond;
 902 }
 903
 904 void InspectorTimelineAgent::onRasterTaskBegin(const TraceEventDispatcher::TraceEvent& event)
 905 {
 906     TimelineThreadState& state = threadState(event.threadIdentifier());
 907     unsigned long long layerId = event.asUInt(InstrumentationEventArguments::LayerId);
 908     ASSERT(layerId);
 909     if (!m_layerToNodeMap.contains(layerId))
 910         return;
 911     ASSERT(!state.inKnownLayerTask);
 912     state.inKnownLayerTask = true;
 913     double timestamp = event.timestamp() * msPerSecond;
 914     RefPtr<JSONObject> data = TimelineRecordFactory::createLayerData(m_layerToNodeMap.get(layerId));
 915     RefPtr<TimelineEvent> record = TimelineRecordFactory::createBackgroundRecord(timestamp, String::number(event.threadIdentifier()), TimelineRecordType::Rasterize, data);
 916     state.recordStack.addScopedRecord(record, TimelineRecordType::Rasterize);
 917 }
 918
 919 void InspectorTimelineAgent::onRasterTaskEnd(const TraceEventDispatcher::TraceEvent& event)
 920 {
 921     TimelineThreadState& state = threadState(event.threadIdentifier());
 922     if (!state.inKnownLayerTask)
 923         return;
 924     ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::Rasterize));
 925     state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
 926     state.inKnownLayerTask = false;
 927 }
 928
 929 void InspectorTimelineAgent::onImageDecodeBegin(const TraceEventDispatcher::TraceEvent& event)
 930 {
 931     TimelineThreadState& state = threadState(event.threadIdentifier());
 932     if (!state.decodedPixelRefId && !state.inKnownLayerTask)
 933         return;
 934     TimelineImageInfo imageInfo;
 935     if (state.decodedPixelRefId) {
 936         PixelRefToImageInfoMap::const_iterator it = m_pixelRefToImageInfo.find(state.decodedPixelRefId);
 937         if (it != m_pixelRefToImageInfo.end())
 938             imageInfo = it->value;
 939         else
 940             ASSERT_NOT_REACHED();
 941     }
 942     RefPtr<JSONObject> data = JSONObject::create();
 943     TimelineRecordFactory::setImageDetails(data.get(), imageInfo.backendNodeId, imageInfo.url);
 944     double timeestamp = event.timestamp() * msPerSecond;
 945     state.recordStack.addScopedRecord(TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), TimelineRecordType::DecodeImage, data), TimelineRecordType::DecodeImage);
 946 }
 947
 948 void InspectorTimelineAgent::onImageDecodeEnd(const TraceEventDispatcher::TraceEvent& event)
 949 {
 950     TimelineThreadState& state = threadState(event.threadIdentifier());
 951     if (!state.decodedPixelRefId)
 952         return;
 953     ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::DecodeImage));
 954     state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
 955 }
 956
 957 void InspectorTimelineAgent::onRequestMainThreadFrame(const TraceEventDispatcher::TraceEvent& event)
 958 {
 959     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
 960     if (layerTreeId != m_layerTreeId)
 961         return;
 962     TimelineThreadState& state = threadState(event.threadIdentifier());
 963     state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::RequestMainThreadFrame, JSONObject::create()));
 964 }
 965
 966 void InspectorTimelineAgent::onActivateLayerTree(const TraceEventDispatcher::TraceEvent& event)
 967 {
 968     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
 969     if (layerTreeId != m_layerTreeId)
 970         return;
 971     unsigned long long frameId = event.asUInt(InstrumentationEventArguments::FrameId);
 972     TimelineThreadState& state = threadState(event.threadIdentifier());
 973     state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::ActivateLayerTree, TimelineRecordFactory::createFrameData(frameId)));
 974 }
 975
 976 void InspectorTimelineAgent::onDrawFrame(const TraceEventDispatcher::TraceEvent& event)
 977 {
 978     unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
 979     if (layerTreeId != m_layerTreeId)
 980         return;
 981     TimelineThreadState& state = threadState(event.threadIdentifier());
 982     state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::DrawFrame, JSONObject::create()));
 983 }
 984
 985 void InspectorTimelineAgent::onLayerDeleted(const TraceEventDispatcher::TraceEvent& event)
 986 {
 987     unsigned long long id = event.id();
 988     ASSERT(id);
 989     m_layerToNodeMap.remove(id);
 990 }
 991
 992 void InspectorTimelineAgent::onDecodeLazyPixelRefBegin(const TraceEventDispatcher::TraceEvent& event)
 993 {
 994     TimelineThreadState& state = threadState(event.threadIdentifier());
 995     ASSERT(!state.decodedPixelRefId);
 996     unsigned long long pixelRefId = event.asUInt(PlatformInstrumentation::LazyPixelRef);
 997     ASSERT(pixelRefId);
 998     if (m_pixelRefToImageInfo.contains(pixelRefId))
 999         state.decodedPixelRefId = pixelRefId;
1000 }
1001
1002 void InspectorTimelineAgent::onDecodeLazyPixelRefEnd(const TraceEventDispatcher::TraceEvent& event)
1003 {
1004     threadState(event.threadIdentifier()).decodedPixelRefId = 0;
1005 }
1006
1007 void InspectorTimelineAgent::onDrawLazyPixelRef(const TraceEventDispatcher::TraceEvent& event)
1008 {
1009     unsigned long long pixelRefId = event.asUInt(PlatformInstrumentation::LazyPixelRef);
1010     ASSERT(pixelRefId);
1011     if (!m_imageBeingPainted)
1012         return;
1013     String url;
1014     if (const ImageResource* resource = m_imageBeingPainted->cachedImage())
1015         url = resource->url().string();
1016     m_pixelRefToImageInfo.set(pixelRefId, TimelineImageInfo(nodeId(m_imageBeingPainted->generatingNode()), url));
1017 }
1018
1019 void InspectorTimelineAgent::onLazyPixelRefDeleted(const TraceEventDispatcher::TraceEvent& event)
1020 {
1021     m_pixelRefToImageInfo.remove(event.id());
1022 }
1023
1024 void InspectorTimelineAgent::processGPUEvent(const GPUEvent& event)
1025 {
1026     double timelineTimestamp = event.timestamp * msPerSecond;
1027     if (event.phase == GPUEvent::PhaseBegin) {
1028         m_pendingGPURecord = TimelineRecordFactory::createBackgroundRecord(timelineTimestamp, "gpu", TimelineRecordType::GPUTask, TimelineRecordFactory::createGPUTaskData(event.foreign));
1029     } else if (m_pendingGPURecord) {
1030         m_pendingGPURecord->setEndTime(timelineTimestamp);
1031         sendEvent(m_pendingGPURecord.release());
1032         if (!event.foreign && m_state->getBoolean(TimelineAgentState::includeCounters)) {
1033             RefPtr<TypeBuilder::Timeline::Counters> counters = TypeBuilder::Timeline::Counters::create();
1034             counters->setGpuMemoryUsedKB(static_cast<double>(event.usedGPUMemoryBytes / 1024));
1035             counters->setGpuMemoryLimitKB(static_cast<double>(event.limitGPUMemoryBytes / 1024));
1036             sendEvent(TimelineRecordFactory::createBackgroundRecord(timelineTimestamp, "gpu", TimelineRecordType::UpdateCounters, counters.release()->asObject()));
1037         }
1038     }
1039 }
1040
1041 void InspectorTimelineAgent::onEmbedderCallbackBegin(const TraceEventDispatcher::TraceEvent& event)
1042 {
1043     TimelineThreadState& state = threadState(event.threadIdentifier());
1044     double timestamp = event.timestamp() * msPerSecond;
1045     RefPtr<JSONObject> data = TimelineRecordFactory::createEmbedderCallbackData(event.asString(InstrumentationEventArguments::CallbackName));
1046     RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp, 0, TimelineRecordType::EmbedderCallback, data);
1047     state.recordStack.addScopedRecord(record, TimelineRecordType::EmbedderCallback);
1048 }
1049
1050 void InspectorTimelineAgent::onEmbedderCallbackEnd(const TraceEventDispatcher::TraceEvent& event)
1051 {
1052     TimelineThreadState& state = threadState(event.threadIdentifier());
1053     state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
1054 }
1055
1056 void InspectorTimelineAgent::addRecordToTimeline(PassRefPtr<TimelineEvent> record, double ts)
1057 {
1058     commitFrameRecord();
1059     innerAddRecordToTimeline(record);
1060     if (m_bufferedEvents && ts - m_lastProgressTimestamp > 300) {
1061         m_lastProgressTimestamp = ts;
1062         m_frontend->progress(m_bufferedEvents->length());
1063     }
1064 }
1065
1066 void InspectorTimelineAgent::innerAddRecordToTimeline(PassRefPtr<TimelineEvent> record)
1067 {
1068     if (m_recordStack.isEmpty()) {
1069         TraceEventDispatcher::instance()->processBackgroundEvents();
1070         sendEvent(record);
1071     } else {
1072         TimelineRecordEntry& parent = m_recordStack.last();
1073         parent.children->addItem(record);
1074         if (m_state->getBoolean(TimelineAgentState::includeCounters))
1075             parent.children->addItem(createCountersUpdate());
1076     }
1077 }
1078
1079 static size_t getUsedHeapSize()
1080 {
1081     HeapInfo info;
1082     ScriptGCEvent::getHeapSize(info);
1083     return info.usedJSHeapSize;
1084 }
1085
1086 PassRefPtr<TypeBuilder::Timeline::TimelineEvent> InspectorTimelineAgent::createCountersUpdate()
1087 {
1088     RefPtr<TypeBuilder::Timeline::Counters> counters = TypeBuilder::Timeline::Counters::create();
1089     if (m_inspectorType == PageInspector) {
1090         counters->setDocuments(InspectorCounters::counterValue(InspectorCounters::DocumentCounter));
1091         counters->setNodes(InspectorCounters::counterValue(InspectorCounters::NodeCounter));
1092         counters->setJsEventListeners(InspectorCounters::counterValue(InspectorCounters::JSEventListenerCounter));
1093     }
1094     counters->setJsHeapSizeUsed(static_cast<double>(getUsedHeapSize()));
1095     return TimelineRecordFactory::createGenericRecord(timestamp(), 0, TimelineRecordType::UpdateCounters, counters.release()->asObject());
1096 }
1097
1098 void InspectorTimelineAgent::setFrameIdentifier(TimelineEvent* record, LocalFrame* frame)
1099 {
1100     if (!frame || !m_pageAgent)
1101         return;
1102     String frameId;
1103     if (frame && m_pageAgent)
1104         frameId = m_pageAgent->frameId(frame);
1105     record->setFrameId(frameId);
1106 }
1107
1108 void InspectorTimelineAgent::populateImageDetails(JSONObject* data, const RenderImage& renderImage)
1109 {
1110     const ImageResource* resource = renderImage.cachedImage();
1111     TimelineRecordFactory::setImageDetails(data, nodeId(renderImage.generatingNode()), resource ? resource->url().string() : "");
1112 }
1113
1114 void InspectorTimelineAgent::didCompleteCurrentRecord(const String& type)
1115 {
1116     // An empty stack could merely mean that the timeline agent was turned on in the middle of
1117     // an event. Don't treat as an error.
1118     if (!m_recordStack.isEmpty()) {
1119         if (m_platformInstrumentationClientInstalledAtStackDepth == m_recordStack.size()) {
1120             m_platformInstrumentationClientInstalledAtStackDepth = 0;
1121             PlatformInstrumentation::setClient(0);
1122         }
1123
1124         TimelineRecordEntry entry = m_recordStack.last();
1125         m_recordStack.removeLast();
1126         while (entry.type != type && entry.skipWhenUnbalanced && !m_recordStack.isEmpty()) {
1127             // Discard pending skippable entry, paste its children inplace.
1128             if (entry.children)
1129                 m_recordStack.last().children->concat(entry.children);
1130             entry = m_recordStack.last();
1131             m_recordStack.removeLast();
1132         }
1133         ASSERT(entry.type == type);
1134         entry.record->setChildren(entry.children);
1135         double ts = timestamp();
1136         entry.record->setEndTime(ts);
1137         addRecordToTimeline(entry.record, ts);
1138     }
1139 }
1140
1141 void InspectorTimelineAgent::unwindRecordStack()
1142 {
1143     while (!m_recordStack.isEmpty()) {
1144         TimelineRecordEntry& entry = m_recordStack.last();
1145         didCompleteCurrentRecord(entry.type);
1146     }
1147 }
1148
1149 InspectorTimelineAgent::InspectorTimelineAgent(InspectorPageAgent* pageAgent, InspectorLayerTreeAgent* layerTreeAgent,
1150     InspectorOverlay* overlay, InspectorType type, InspectorClient* client)
1151     : InspectorBaseAgent<InspectorTimelineAgent>("Timeline")
1152     , m_pageAgent(pageAgent)
1153     , m_layerTreeAgent(layerTreeAgent)
1154     , m_frontend(0)
1155     , m_client(client)
1156     , m_overlay(overlay)
1157     , m_inspectorType(type)
1158     , m_id(1)
1159     , m_layerTreeId(0)
1160     , m_maxCallStackDepth(5)
1161     , m_platformInstrumentationClientInstalledAtStackDepth(0)
1162     , m_imageBeingPainted(0)
1163     , m_paintSetupStart(0)
1164     , m_mayEmitFirstPaint(false)
1165     , m_lastProgressTimestamp(0)
1166 {
1167 }
1168
1169 void InspectorTimelineAgent::appendRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, LocalFrame* frame)
1170 {
1171     double ts = timestamp();
1172     RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(ts, captureCallStack ? m_maxCallStackDepth : 0, type, data);
1173     setFrameIdentifier(record.get(), frame);
1174     addRecordToTimeline(record.release(), ts);
1175 }
1176
1177 void InspectorTimelineAgent::sendEvent(PassRefPtr<TimelineEvent> record)
1178 {
1179     RefPtr<TimelineEvent> retain = record;
1180     if (m_bufferedEvents) {
1181         m_bufferedEvents->addItem(retain);
1182         if (!m_liveEvents.contains(TimelineRecordFactory::type(retain.get())))
1183             return;
1184     }
1185     m_frontend->eventRecorded(retain.release());
1186 }
1187
1188 void InspectorTimelineAgent::pushCurrentRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, LocalFrame* frame, bool hasLowLevelDetails)
1189 {
1190     commitFrameRecord();
1191     RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp(), captureCallStack ? m_maxCallStackDepth : 0, type, data.get());
1192     setFrameIdentifier(record.get(), frame);
1193     m_recordStack.append(TimelineRecordEntry(record.release(), data, TypeBuilder::Array<TimelineEvent>::create(), type));
1194     if (hasLowLevelDetails && !m_platformInstrumentationClientInstalledAtStackDepth && !PlatformInstrumentation::hasClient()) {
1195         m_platformInstrumentationClientInstalledAtStackDepth = m_recordStack.size();
1196         PlatformInstrumentation::setClient(this);
1197     }
1198 }
1199
1200 TimelineThreadState& InspectorTimelineAgent::threadState(ThreadIdentifier thread)
1201 {
1202     ThreadStateMap::iterator it = m_threadStates.find(thread);
1203     if (it != m_threadStates.end())
1204         return it->value;
1205     return m_threadStates.add(thread, TimelineThreadState(this)).storedValue->value;
1206 }
1207
1208 void InspectorTimelineAgent::commitFrameRecord()
1209 {
1210     if (!m_pendingFrameRecord)
1211         return;
1212     innerAddRecordToTimeline(m_pendingFrameRecord.release());
1213 }
1214
1215 void InspectorTimelineAgent::clearRecordStack()
1216 {
1217     if (m_platformInstrumentationClientInstalledAtStackDepth) {
1218         m_platformInstrumentationClientInstalledAtStackDepth = 0;
1219         PlatformInstrumentation::setClient(0);
1220     }
1221     m_pendingFrameRecord.clear();
1222     m_recordStack.clear();
1223     m_id++;
1224 }
1225
1226 void InspectorTimelineAgent::localToPageQuad(const RenderObject& renderer, const LayoutRect& rect, FloatQuad* quad)
1227 {
1228     LocalFrame* frame = renderer.frame();
1229     FrameView* view = frame->view();
1230     FloatQuad absolute = renderer.localToAbsoluteQuad(FloatQuad(rect));
1231     quad->setP1(view->contentsToRootView(roundedIntPoint(absolute.p1())));
1232     quad->setP2(view->contentsToRootView(roundedIntPoint(absolute.p2())));
1233     quad->setP3(view->contentsToRootView(roundedIntPoint(absolute.p3())));
1234     quad->setP4(view->contentsToRootView(roundedIntPoint(absolute.p4())));
1235 }
1236
1237 long long InspectorTimelineAgent::nodeId(Node* node)
1238 {
1239     return node ? InspectorNodeIds::idForNode(node)  : 0;
1240 }
1241
1242 long long InspectorTimelineAgent::nodeId(RenderObject* renderer)
1243 {
1244     return InspectorNodeIds::idForNode(renderer->generatingNode());
1245 }
1246
1247 double InspectorTimelineAgent::timestamp()
1248 {
1249     return WTF::monotonicallyIncreasingTime() * msPerSecond;
1250 }
1251
1252 LocalFrame* InspectorTimelineAgent::mainFrame() const
1253 {
1254     if (!m_pageAgent)
1255         return 0;
1256     return m_pageAgent->mainFrame();
1257 }
1258
1259 PassRefPtr<TimelineEvent> InspectorTimelineAgent::createRecordForEvent(const TraceEventDispatcher::TraceEvent& event, const String& type, PassRefPtr<JSONObject> data)
1260 {
1261     double timeestamp = event.timestamp() * msPerSecond;
1262     return TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), type, data);
1263 }
1264
1265 void InspectorTimelineAgent::setLiveEvents(const String& liveEvents)
1266 {
1267     m_liveEvents.clear();
1268     if (liveEvents.isNull() || liveEvents.isEmpty())
1269         return;
1270     Vector<String> eventList;
1271     liveEvents.split(",", eventList);
1272     for (Vector<String>::iterator it = eventList.begin(); it != eventList.end(); ++it)
1273         m_liveEvents.add(*it);
1274 }
1275
1276 TimelineRecordStack::TimelineRecordStack(InspectorTimelineAgent* timelineAgent)
1277     : m_timelineAgent(timelineAgent)
1278 {
1279 }
1280
1281 void TimelineRecordStack::addScopedRecord(PassRefPtr<TimelineEvent> record, const String& type)
1282 {
1283     m_stack.append(Entry(record, type));
1284 }
1285
1286 void TimelineRecordStack::closeScopedRecord(double endTime)
1287 {
1288     if (m_stack.isEmpty())
1289         return;
1290     Entry last = m_stack.last();
1291     m_stack.removeLast();
1292     last.record->setEndTime(endTime);
1293     if (last.children->length())
1294         last.record->setChildren(last.children);
1295     addInstantRecord(last.record);
1296 }
1297
1298 void TimelineRecordStack::addInstantRecord(PassRefPtr<TimelineEvent> record)
1299 {
1300     if (m_stack.isEmpty())
1301         m_timelineAgent->sendEvent(record);
1302     else
1303         m_stack.last().children->addItem(record);
1304 }
1305
1306 #ifndef NDEBUG
1307 bool TimelineRecordStack::isOpenRecordOfType(const String& type)
1308 {
1309     return !m_stack.isEmpty() && m_stack.last().type == type;
1310 }
1311 #endif
1312
1313 } // namespace WebCore
1314