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