#include "core/events/Event.h"
#include "core/frame/DOMWindow.h"
-#include "core/frame/Frame.h"
+#include "core/frame/FrameConsole.h"
#include "core/frame/FrameHost.h"
#include "core/frame/FrameView.h"
+#include "core/frame/LocalFrame.h"
#include "core/inspector/IdentifiersFactory.h"
#include "core/inspector/InspectorClient.h"
#include "core/inspector/InspectorCounters.h"
-#include "core/inspector/InspectorDOMAgent.h"
#include "core/inspector/InspectorInstrumentation.h"
+#include "core/inspector/InspectorLayerTreeAgent.h"
+#include "core/inspector/InspectorNodeIds.h"
#include "core/inspector/InspectorOverlay.h"
#include "core/inspector/InspectorPageAgent.h"
#include "core/inspector/InspectorState.h"
#include "core/inspector/TraceEventDispatcher.h"
#include "core/loader/DocumentLoader.h"
#include "core/page/Page.h"
-#include "core/frame/PageConsole.h"
#include "core/rendering/RenderObject.h"
#include "core/rendering/RenderView.h"
#include "core/xml/XMLHttpRequest.h"
#include "platform/graphics/GraphicsLayer.h"
#include "platform/network/ResourceRequest.h"
#include "wtf/CurrentTime.h"
+#include "wtf/DateMath.h"
namespace WebCore {
static const char includeCounters[] = "includeCounters";
static const char includeGPUEvents[] = "includeGPUEvents";
static const char bufferEvents[] = "bufferEvents";
+static const char liveEvents[] = "liveEvents";
}
// Must be kept in sync with WebInspector.TimelineModel.RecordType in TimelineModel.js
static const char RecalculateStyles[] = "RecalculateStyles";
static const char InvalidateLayout[] = "InvalidateLayout";
static const char Layout[] = "Layout";
-static const char AutosizeText[] = "AutosizeText";
+static const char UpdateLayerTree[] = "UpdateLayerTree";
static const char Paint[] = "Paint";
static const char ScrollLayer[] = "ScrollLayer";
static const char ResizeImage[] = "ResizeImage";
static const char MarkFirstPaint[] = "MarkFirstPaint";
static const char TimeStamp[] = "TimeStamp";
-static const char Time[] = "Time";
-static const char TimeEnd[] = "TimeEnd";
+static const char ConsoleTime[] = "ConsoleTime";
-static const char ScheduleResourceRequest[] = "ScheduleResourceRequest";
static const char ResourceSendRequest[] = "ResourceSendRequest";
static const char ResourceReceiveResponse[] = "ResourceReceiveResponse";
static const char ResourceReceivedData[] = "ResourceReceivedData";
static const char FunctionCall[] = "FunctionCall";
static const char GCEvent[] = "GCEvent";
+static const char UpdateCounters[] = "UpdateCounters";
+
static const char RequestAnimationFrame[] = "RequestAnimationFrame";
static const char CancelAnimationFrame[] = "CancelAnimationFrame";
static const char FireAnimationFrame[] = "FireAnimationFrame";
static const char WebSocketReceiveHandshakeResponse[] = "WebSocketReceiveHandshakeResponse";
static const char WebSocketDestroy[] = "WebSocketDestroy";
-// Event names visible to other modules.
-const char ActivateLayerTree[] = "ActivateLayerTree";
-const char BeginFrame[] = "BeginFrame";
-const char DecodeImage[] = "DecodeImage";
-const char GPUTask[] = "GPUTask";
-const char Rasterize[] = "Rasterize";
-const char PaintSetup[] = "PaintSetup";
-}
+static const char RequestMainThreadFrame[] = "RequestMainThreadFrame";
+static const char ActivateLayerTree[] = "ActivateLayerTree";
+static const char DrawFrame[] = "DrawFrame";
+static const char BeginFrame[] = "BeginFrame";
+static const char DecodeImage[] = "DecodeImage";
+static const char GPUTask[] = "GPUTask";
+static const char Rasterize[] = "Rasterize";
+static const char PaintSetup[] = "PaintSetup";
-namespace {
-const char BackendNodeIdGroup[] = "timeline";
+static const char EmbedderCallback[] = "EmbedderCallback";
}
using TypeBuilder::Timeline::TimelineEvent;
struct TimelineRecordEntry {
- TimelineRecordEntry(PassRefPtr<TimelineEvent> record, PassRefPtr<JSONObject> data, PassRefPtr<TypeBuilder::Array<TimelineEvent> > children, const String& type, size_t usedHeapSizeAtStart)
- : record(record), data(data), children(children), type(type), usedHeapSizeAtStart(usedHeapSizeAtStart)
+ TimelineRecordEntry(PassRefPtr<TimelineEvent> record, PassRefPtr<JSONObject> data, PassRefPtr<TypeBuilder::Array<TimelineEvent> > children, const String& type)
+ : record(record)
+ , data(data)
+ , children(children)
+ , type(type)
+ , skipWhenUnbalanced(false)
{
}
RefPtr<TimelineEvent> record;
RefPtr<JSONObject> data;
RefPtr<TypeBuilder::Array<TimelineEvent> > children;
String type;
- size_t usedHeapSizeAtStart;
+ bool skipWhenUnbalanced;
};
class TimelineRecordStack {
unsigned long long decodedPixelRefId;
};
-struct TimelineGCEvent {
- TimelineGCEvent(double startTime, double endTime, size_t collectedBytes)
- : startTime(startTime), endTime(endTime), collectedBytes(collectedBytes)
- {
- }
- double startTime;
- double endTime;
- size_t collectedBytes;
-};
-
struct TimelineImageInfo {
int backendNodeId;
String url;
TimelineImageInfo(int backendNodeId, String url) : backendNodeId(backendNodeId), url(url) { }
};
-static Frame* frameForExecutionContext(ExecutionContext* context)
+static LocalFrame* frameForExecutionContext(ExecutionContext* context)
{
- Frame* frame = 0;
+ LocalFrame* frame = 0;
if (context->isDocument())
frame = toDocument(context)->frame();
return frame;
return false;
}
-void TimelineTimeConverter::reset()
-{
- m_startOffset = monotonicallyIncreasingTime() - currentTime();
-}
-
-void InspectorTimelineAgent::pushGCEventRecords()
-{
- if (!m_gcEvents.size())
- return;
-
- GCEvents events = m_gcEvents;
- m_gcEvents.clear();
- for (GCEvents::iterator i = events.begin(); i != events.end(); ++i) {
- RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(m_timeConverter.fromMonotonicallyIncreasingTime(i->startTime), m_maxCallStackDepth, TimelineRecordType::GCEvent, TimelineRecordFactory::createGCEventData(i->collectedBytes));
- record->setEndTime(m_timeConverter.fromMonotonicallyIncreasingTime(i->endTime));
- addRecordToTimeline(record.release());
- }
-}
-
void InspectorTimelineAgent::didGC(double startTime, double endTime, size_t collectedBytesCount)
{
- m_gcEvents.append(TimelineGCEvent(startTime, endTime, collectedBytesCount));
+ RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(
+ startTime * msPerSecond,
+ 0,
+ TimelineRecordType::GCEvent,
+ TimelineRecordFactory::createGCEventData(collectedBytesCount));
+ record->setEndTime(endTime * msPerSecond);
+ double time = timestamp();
+ addRecordToTimeline(record.release(), time);
+ if (m_state->getBoolean(TimelineAgentState::includeCounters)) {
+ addRecordToTimeline(createCountersUpdate(), time);
+ }
}
InspectorTimelineAgent::~InspectorTimelineAgent()
RefPtr<TypeBuilder::Array<TimelineEvent> > events;
stop(&error, events);
disable(&error);
- releaseNodeIds();
m_frontend = 0;
}
if (m_state->getBoolean(TimelineAgentState::startedFromProtocol)) {
if (m_state->getBoolean(TimelineAgentState::bufferEvents))
m_bufferedEvents = TypeBuilder::Array<TimelineEvent>::create();
+
+ setLiveEvents(m_state->getString(TimelineAgentState::liveEvents));
innerStart();
} else if (isStarted()) {
// Timeline was started from console.timeline, it is not restored.
m_state->setBoolean(TimelineAgentState::enabled, false);
}
-void InspectorTimelineAgent::start(ErrorString* errorString, const int* maxCallStackDepth, const bool* bufferEvents, const bool* includeCounters, const bool* includeGPUEvents)
+void InspectorTimelineAgent::start(ErrorString* errorString, const int* maxCallStackDepth, const bool* bufferEvents, const String* liveEvents, const bool* includeCounters, const bool* includeGPUEvents)
{
if (!m_frontend)
return;
return;
}
- releaseNodeIds();
if (maxCallStackDepth && *maxCallStackDepth >= 0)
m_maxCallStackDepth = *maxCallStackDepth;
else
m_maxCallStackDepth = 5;
- if (bufferEvents && *bufferEvents)
+ if (bufferEvents && *bufferEvents) {
m_bufferedEvents = TypeBuilder::Array<TimelineEvent>::create();
+ m_lastProgressTimestamp = timestamp();
+ }
+
+ if (liveEvents)
+ setLiveEvents(*liveEvents);
m_state->setLong(TimelineAgentState::timelineMaxCallStackDepth, m_maxCallStackDepth);
m_state->setBoolean(TimelineAgentState::includeCounters, includeCounters && *includeCounters);
m_state->setBoolean(TimelineAgentState::includeGPUEvents, includeGPUEvents && *includeGPUEvents);
m_state->setBoolean(TimelineAgentState::bufferEvents, bufferEvents && *bufferEvents);
+ m_state->setString(TimelineAgentState::liveEvents, liveEvents ? *liveEvents : "");
innerStart();
bool fromConsole = false;
if (m_overlay)
m_overlay->startedRecordingProfile();
m_state->setBoolean(TimelineAgentState::started, true);
- m_timeConverter.reset();
m_instrumentingAgents->setInspectorTimelineAgent(this);
ScriptGCEvent::addEventListener(this);
if (m_client) {
dispatcher->addListener(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onRasterTaskBegin, m_client);
dispatcher->addListener(InstrumentationEvents::RasterTask, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onRasterTaskEnd, m_client);
dispatcher->addListener(InstrumentationEvents::Layer, TRACE_EVENT_PHASE_DELETE_OBJECT, this, &InspectorTimelineAgent::onLayerDeleted, m_client);
+ dispatcher->addListener(InstrumentationEvents::RequestMainThreadFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onRequestMainThreadFrame, m_client);
dispatcher->addListener(InstrumentationEvents::ActivateLayerTree, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onActivateLayerTree, m_client);
+ dispatcher->addListener(InstrumentationEvents::DrawFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onDrawFrame, m_client);
dispatcher->addListener(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onImageDecodeBegin, m_client);
dispatcher->addListener(PlatformInstrumentation::ImageDecodeEvent, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onImageDecodeEnd, m_client);
dispatcher->addListener(PlatformInstrumentation::DrawLazyPixelRefEvent, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onDrawLazyPixelRef, m_client);
dispatcher->addListener(PlatformInstrumentation::DecodeLazyPixelRefEvent, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onDecodeLazyPixelRefBegin, m_client);
dispatcher->addListener(PlatformInstrumentation::DecodeLazyPixelRefEvent, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onDecodeLazyPixelRefEnd, m_client);
dispatcher->addListener(PlatformInstrumentation::LazyPixelRef, TRACE_EVENT_PHASE_DELETE_OBJECT, this, &InspectorTimelineAgent::onLazyPixelRefDeleted, m_client);
+ dispatcher->addListener(InstrumentationEvents::EmbedderCallback, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onEmbedderCallbackBegin, m_client);
+ dispatcher->addListener(InstrumentationEvents::EmbedderCallback, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onEmbedderCallbackEnd, m_client);
if (m_state->getBoolean(TimelineAgentState::includeGPUEvents)) {
m_pendingGPURecord.clear();
{
m_state->setBoolean(TimelineAgentState::startedFromProtocol, false);
m_state->setBoolean(TimelineAgentState::bufferEvents, false);
+ m_state->setString(TimelineAgentState::liveEvents, "");
if (!isStarted()) {
*errorString = "Timeline was not started";
innerStop(false);
if (m_bufferedEvents)
events = m_bufferedEvents.release();
+ m_liveEvents.clear();
}
void InspectorTimelineAgent::innerStop(bool fromConsole)
clearRecordStack();
m_threadStates.clear();
- m_gcEvents.clear();
m_gpuTask.clear();
m_layerToNodeMap.clear();
m_pixelRefToImageInfo.clear();
for (size_t i = 0; i < m_consoleTimelines.size(); ++i) {
String message = String::format("Timeline '%s' terminated.", m_consoleTimelines[i].utf8().data());
- frameHost()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message);
+ mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message);
}
m_consoleTimelines.clear();
m_pendingFrameRecord.clear();
}
-bool InspectorTimelineAgent::willCallFunction(ExecutionContext* context, const String& scriptName, int scriptLine)
+bool InspectorTimelineAgent::willCallFunction(ExecutionContext* context, int scriptId, const String& scriptName, int scriptLine)
{
- pushCurrentRecord(TimelineRecordFactory::createFunctionCallData(scriptName, scriptLine), TimelineRecordType::FunctionCall, true, frameForExecutionContext(context));
+ pushCurrentRecord(TimelineRecordFactory::createFunctionCallData(scriptId, scriptName, scriptLine), TimelineRecordType::FunctionCall, true, frameForExecutionContext(context));
return true;
}
bool InspectorTimelineAgent::willDispatchEvent(Document* document, const Event& event, DOMWindow* window, Node* node, const EventPath& eventPath)
{
if (!eventHasListeners(event.type(), window, node, eventPath))
- return false;
+ return false;
pushCurrentRecord(TimelineRecordFactory::createEventDispatchData(event), TimelineRecordType::EventDispatch, false, document->frame());
return true;
didDispatchEvent();
}
-void InspectorTimelineAgent::didInvalidateLayout(Frame* frame)
+void InspectorTimelineAgent::didInvalidateLayout(LocalFrame* frame)
{
appendRecord(JSONObject::create(), TimelineRecordType::InvalidateLayout, true, frame);
}
-bool InspectorTimelineAgent::willLayout(Frame* frame)
+bool InspectorTimelineAgent::willLayout(LocalFrame* frame)
{
bool isPartial;
unsigned needsLayoutObjects;
didCompleteCurrentRecord(TimelineRecordType::Layout);
}
-void InspectorTimelineAgent::willAutosizeText(RenderObject* renderer)
+void InspectorTimelineAgent::layerTreeDidChange()
{
- pushCurrentRecord(TimelineRecordFactory::createNodeData(nodeId(renderer)), TimelineRecordType::AutosizeText, false, renderer->frame());
+ ASSERT(!m_pendingLayerTreeData);
+ m_pendingLayerTreeData = m_layerTreeAgent->buildLayerTree();
}
-void InspectorTimelineAgent::didAutosizeText(RenderObject* renderer)
+void InspectorTimelineAgent::willUpdateLayerTree()
{
- if (renderer->needsLayout()) {
- TimelineRecordEntry& entry = m_recordStack.last();
- ASSERT(entry.type == TimelineRecordType::AutosizeText);
- entry.data->setBoolean("needsRelayout", true);
- }
- didCompleteCurrentRecord(TimelineRecordType::AutosizeText);
+ pushCurrentRecord(JSONObject::create(), TimelineRecordType::UpdateLayerTree, false, 0);
+}
+
+void InspectorTimelineAgent::didUpdateLayerTree()
+{
+ if (m_recordStack.isEmpty())
+ return;
+ TimelineRecordEntry& entry = m_recordStack.last();
+ ASSERT(entry.type == TimelineRecordType::UpdateLayerTree);
+ if (m_pendingLayerTreeData)
+ TimelineRecordFactory::setLayerTreeData(entry.data.get(), m_pendingLayerTreeData.release());
+ didCompleteCurrentRecord(TimelineRecordType::UpdateLayerTree);
}
void InspectorTimelineAgent::didScheduleStyleRecalculation(Document* document)
bool InspectorTimelineAgent::willRecalculateStyle(Document* document)
{
pushCurrentRecord(JSONObject::create(), TimelineRecordType::RecalculateStyles, true, document->frame());
- ASSERT(!m_styleRecalcElementCounter);
return true;
}
-void InspectorTimelineAgent::didRecalculateStyle()
+void InspectorTimelineAgent::didRecalculateStyle(int elementCount)
{
if (m_recordStack.isEmpty())
return;
TimelineRecordEntry& entry = m_recordStack.last();
ASSERT(entry.type == TimelineRecordType::RecalculateStyles);
- TimelineRecordFactory::setStyleRecalcDetails(entry.data.get(), m_styleRecalcElementCounter);
- m_styleRecalcElementCounter = 0;
+ TimelineRecordFactory::setStyleRecalcDetails(entry.data.get(), elementCount);
didCompleteCurrentRecord(TimelineRecordType::RecalculateStyles);
}
-void InspectorTimelineAgent::didRecalculateStyleForElement()
-{
- ++m_styleRecalcElementCounter;
-}
-
void InspectorTimelineAgent::willPaint(RenderObject* renderer, const GraphicsLayer* graphicsLayer)
{
- Frame* frame = renderer->frame();
+ LocalFrame* frame = renderer->frame();
TraceEventDispatcher::instance()->processBackgroundEvents();
double paintSetupStart = m_paintSetupStart;
if (paintSetupStart) {
RefPtr<TimelineEvent> paintSetupRecord = TimelineRecordFactory::createGenericRecord(paintSetupStart, 0, TimelineRecordType::PaintSetup, TimelineRecordFactory::createLayerData(nodeIdentifier));
paintSetupRecord->setEndTime(m_paintSetupEnd);
- addRecordToTimeline(paintSetupRecord);
+ addRecordToTimeline(paintSetupRecord, paintSetupStart);
}
}
pushCurrentRecord(JSONObject::create(), TimelineRecordType::Paint, true, frame, true);
didCompleteCurrentRecord(TimelineRecordType::XHRLoad);
}
-bool InspectorTimelineAgent::willEvaluateScript(Frame* frame, const String& url, int lineNumber)
+bool InspectorTimelineAgent::willEvaluateScript(LocalFrame* frame, const String& url, int lineNumber)
{
pushCurrentRecord(TimelineRecordFactory::createEvaluateScriptData(url, lineNumber), TimelineRecordType::EvaluateScript, true, frame);
return true;
didCompleteCurrentRecord(TimelineRecordType::EvaluateScript);
}
-void InspectorTimelineAgent::didScheduleResourceRequest(Document* document, const String& url)
-{
- appendRecord(TimelineRecordFactory::createScheduleResourceRequestData(url), TimelineRecordType::ScheduleResourceRequest, true, document->frame());
-}
-
void InspectorTimelineAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, const ResourceRequest& request, const ResourceResponse&, const FetchInitiatorInfo&)
{
String requestId = IdentifiersFactory::requestId(identifier);
appendRecord(TimelineRecordFactory::createResourceSendRequestData(requestId, request), TimelineRecordType::ResourceSendRequest, true, loader->frame());
}
-bool InspectorTimelineAgent::willReceiveResourceData(Frame* frame, unsigned long identifier, int length)
+void InspectorTimelineAgent::didReceiveData(LocalFrame* frame, unsigned long identifier, const char*, int, int encodedDataLength)
{
String requestId = IdentifiersFactory::requestId(identifier);
- pushCurrentRecord(TimelineRecordFactory::createReceiveResourceData(requestId, length), TimelineRecordType::ResourceReceivedData, false, frame);
- return true;
+ appendRecord(TimelineRecordFactory::createReceiveResourceData(requestId, encodedDataLength), TimelineRecordType::ResourceReceivedData, false, frame);
}
-void InspectorTimelineAgent::didReceiveResourceData()
-{
- didCompleteCurrentRecord(TimelineRecordType::ResourceReceivedData);
-}
-
-void InspectorTimelineAgent::didReceiveResourceResponse(Frame* frame, unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
+void InspectorTimelineAgent::didReceiveResourceResponse(LocalFrame* frame, unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
{
String requestId = IdentifiersFactory::requestId(identifier);
- appendRecord(TimelineRecordFactory::createResourceReceiveResponseData(requestId, response), TimelineRecordType::ResourceReceiveResponse, false, frame);
+ appendRecord(TimelineRecordFactory::createResourceReceiveResponseData(requestId, response), TimelineRecordType::ResourceReceiveResponse, false, 0);
}
-void InspectorTimelineAgent::didFinishLoadingResource(unsigned long identifier, bool didFail, double finishTime, Frame* frame)
+void InspectorTimelineAgent::didFinishLoadingResource(unsigned long identifier, bool didFail, double finishTime)
{
- appendRecord(TimelineRecordFactory::createResourceFinishData(IdentifiersFactory::requestId(identifier), didFail, finishTime * 1000), TimelineRecordType::ResourceFinish, false, frame);
+ appendRecord(TimelineRecordFactory::createResourceFinishData(IdentifiersFactory::requestId(identifier), didFail, finishTime), TimelineRecordType::ResourceFinish, false, 0);
}
-void InspectorTimelineAgent::didFinishLoading(unsigned long identifier, DocumentLoader* loader, double monotonicFinishTime)
+void InspectorTimelineAgent::didFinishLoading(unsigned long identifier, DocumentLoader* loader, double monotonicFinishTime, int64_t)
{
- double finishTime = 0.0;
- // FIXME: Expose all of the timing details to inspector and have it calculate finishTime.
- if (monotonicFinishTime)
- finishTime = loader->timing()->monotonicTimeToPseudoWallTime(monotonicFinishTime);
-
- didFinishLoadingResource(identifier, false, finishTime, loader->frame());
+ didFinishLoadingResource(identifier, false, monotonicFinishTime * msPerSecond);
}
-void InspectorTimelineAgent::didFailLoading(unsigned long identifier, DocumentLoader* loader, const ResourceError& error)
+void InspectorTimelineAgent::didFailLoading(unsigned long identifier, const ResourceError& error)
{
- didFinishLoadingResource(identifier, true, 0, loader->frame());
+ didFinishLoadingResource(identifier, true, 0);
}
void InspectorTimelineAgent::consoleTimeStamp(ExecutionContext* context, const String& title)
void InspectorTimelineAgent::consoleTime(ExecutionContext* context, const String& message)
{
- appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::Time, true, frameForExecutionContext(context));
+ pushCurrentRecord(TimelineRecordFactory::createConsoleTimeData(message), TimelineRecordType::ConsoleTime, false, frameForExecutionContext(context));
+ m_recordStack.last().skipWhenUnbalanced = true;
}
void InspectorTimelineAgent::consoleTimeEnd(ExecutionContext* context, const String& message, ScriptState*)
{
- appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeEnd, true, frameForExecutionContext(context));
+ if (m_recordStack.last().type != TimelineRecordType::ConsoleTime)
+ return;
+ String originalMessage;
+ if (m_recordStack.last().data->getString("message", &originalMessage) && message != originalMessage)
+ return;
+ // Only complete console.time that is balanced.
+ didCompleteCurrentRecord(TimelineRecordType::ConsoleTime);
}
-void InspectorTimelineAgent::consoleTimeline(ExecutionContext* context, const String& title, ScriptState* state)
+void InspectorTimelineAgent::consoleTimeline(ExecutionContext* context, const String& title, ScriptState* scriptState)
{
if (!m_state->getBoolean(TimelineAgentState::enabled))
return;
String message = String::format("Timeline '%s' started.", title.utf8().data());
- frameHost()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+ mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
m_consoleTimelines.append(title);
if (!isStarted()) {
innerStart();
appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeStamp, true, frameForExecutionContext(context));
}
-void InspectorTimelineAgent::consoleTimelineEnd(ExecutionContext* context, const String& title, ScriptState* state)
+void InspectorTimelineAgent::consoleTimelineEnd(ExecutionContext* context, const String& title, ScriptState* scriptState)
{
if (!m_state->getBoolean(TimelineAgentState::enabled))
return;
size_t index = m_consoleTimelines.find(title);
if (index == kNotFound) {
String message = String::format("Timeline '%s' was not started.", title.utf8().data());
- frameHost()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+ mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
return;
}
unwindRecordStack();
innerStop(true);
}
- frameHost()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+ mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, scriptState);
}
-void InspectorTimelineAgent::domContentLoadedEventFired(Frame* frame)
+void InspectorTimelineAgent::domContentLoadedEventFired(LocalFrame* frame)
{
bool isMainFrame = frame && m_pageAgent && (frame == m_pageAgent->mainFrame());
appendRecord(TimelineRecordFactory::createMarkData(isMainFrame), TimelineRecordType::MarkDOMContent, false, frame);
m_mayEmitFirstPaint = true;
}
-void InspectorTimelineAgent::loadEventFired(Frame* frame)
+void InspectorTimelineAgent::loadEventFired(LocalFrame* frame)
{
bool isMainFrame = frame && m_pageAgent && (frame == m_pageAgent->mainFrame());
appendRecord(TimelineRecordFactory::createMarkData(isMainFrame), TimelineRecordType::MarkLoad, false, frame);
appendRecord(TimelineRecordFactory::createWebSocketCreateData(identifier, url, protocol), TimelineRecordType::WebSocketCreate, true, document->frame());
}
-void InspectorTimelineAgent::willSendWebSocketHandshakeRequest(Document* document, unsigned long identifier, const WebSocketHandshakeRequest&)
+void InspectorTimelineAgent::willSendWebSocketHandshakeRequest(Document* document, unsigned long identifier, const WebSocketHandshakeRequest*)
{
appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketSendHandshakeRequest, true, document->frame());
}
-void InspectorTimelineAgent::didReceiveWebSocketHandshakeResponse(Document* document, unsigned long identifier, const WebSocketHandshakeResponse&)
+void InspectorTimelineAgent::didReceiveWebSocketHandshakeResponse(Document* document, unsigned long identifier, const WebSocketHandshakeRequest*, const WebSocketHandshakeResponse*)
{
appendRecord(TimelineRecordFactory::createGenericWebSocketData(identifier), TimelineRecordType::WebSocketReceiveHandshakeResponse, false, document->frame());
}
void InspectorTimelineAgent::onPaintSetupBegin(const TraceEventDispatcher::TraceEvent& event)
{
ASSERT(!m_paintSetupStart);
- m_paintSetupStart = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+ m_paintSetupStart = event.timestamp() * msPerSecond;
}
void InspectorTimelineAgent::onPaintSetupEnd(const TraceEventDispatcher::TraceEvent& event)
{
ASSERT(m_paintSetupStart);
- m_paintSetupEnd = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+ m_paintSetupEnd = event.timestamp() * msPerSecond;
}
void InspectorTimelineAgent::onRasterTaskBegin(const TraceEventDispatcher::TraceEvent& event)
return;
ASSERT(!state.inKnownLayerTask);
state.inKnownLayerTask = true;
- double timestamp = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+ double timestamp = event.timestamp() * msPerSecond;
RefPtr<JSONObject> data = TimelineRecordFactory::createLayerData(m_layerToNodeMap.get(layerId));
RefPtr<TimelineEvent> record = TimelineRecordFactory::createBackgroundRecord(timestamp, String::number(event.threadIdentifier()), TimelineRecordType::Rasterize, data);
state.recordStack.addScopedRecord(record, TimelineRecordType::Rasterize);
if (!state.inKnownLayerTask)
return;
ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::Rasterize));
- state.recordStack.closeScopedRecord(m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp()));
+ state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
state.inKnownLayerTask = false;
}
}
RefPtr<JSONObject> data = JSONObject::create();
TimelineRecordFactory::setImageDetails(data.get(), imageInfo.backendNodeId, imageInfo.url);
- double timeestamp = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+ double timeestamp = event.timestamp() * msPerSecond;
state.recordStack.addScopedRecord(TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), TimelineRecordType::DecodeImage, data), TimelineRecordType::DecodeImage);
}
if (!state.decodedPixelRefId)
return;
ASSERT(state.recordStack.isOpenRecordOfType(TimelineRecordType::DecodeImage));
- state.recordStack.closeScopedRecord(m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp()));
+ state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
+}
+
+void InspectorTimelineAgent::onRequestMainThreadFrame(const TraceEventDispatcher::TraceEvent& event)
+{
+ unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
+ if (layerTreeId != m_layerTreeId)
+ return;
+ TimelineThreadState& state = threadState(event.threadIdentifier());
+ state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::RequestMainThreadFrame, JSONObject::create()));
}
void InspectorTimelineAgent::onActivateLayerTree(const TraceEventDispatcher::TraceEvent& event)
state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::ActivateLayerTree, TimelineRecordFactory::createFrameData(frameId)));
}
+void InspectorTimelineAgent::onDrawFrame(const TraceEventDispatcher::TraceEvent& event)
+{
+ unsigned long long layerTreeId = event.asUInt(InstrumentationEventArguments::LayerTreeId);
+ if (layerTreeId != m_layerTreeId)
+ return;
+ TimelineThreadState& state = threadState(event.threadIdentifier());
+ state.recordStack.addInstantRecord(createRecordForEvent(event, TimelineRecordType::DrawFrame, JSONObject::create()));
+}
+
void InspectorTimelineAgent::onLayerDeleted(const TraceEventDispatcher::TraceEvent& event)
{
unsigned long long id = event.id();
void InspectorTimelineAgent::processGPUEvent(const GPUEvent& event)
{
- double timelineTimestamp = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp);
+ double timelineTimestamp = event.timestamp * msPerSecond;
if (event.phase == GPUEvent::PhaseBegin) {
m_pendingGPURecord = TimelineRecordFactory::createBackgroundRecord(timelineTimestamp, "gpu", TimelineRecordType::GPUTask, TimelineRecordFactory::createGPUTaskData(event.foreign));
} else if (m_pendingGPURecord) {
m_pendingGPURecord->setEndTime(timelineTimestamp);
+ sendEvent(m_pendingGPURecord.release());
if (!event.foreign && m_state->getBoolean(TimelineAgentState::includeCounters)) {
RefPtr<TypeBuilder::Timeline::Counters> counters = TypeBuilder::Timeline::Counters::create();
counters->setGpuMemoryUsedKB(static_cast<double>(event.usedGPUMemoryBytes / 1024));
- m_pendingGPURecord->setCounters(counters.release());
+ counters->setGpuMemoryLimitKB(static_cast<double>(event.limitGPUMemoryBytes / 1024));
+ sendEvent(TimelineRecordFactory::createBackgroundRecord(timelineTimestamp, "gpu", TimelineRecordType::UpdateCounters, counters.release()->asObject()));
}
- sendEvent(m_pendingGPURecord.release());
}
}
-void InspectorTimelineAgent::addRecordToTimeline(PassRefPtr<TimelineEvent> record)
+void InspectorTimelineAgent::onEmbedderCallbackBegin(const TraceEventDispatcher::TraceEvent& event)
+{
+ TimelineThreadState& state = threadState(event.threadIdentifier());
+ double timestamp = event.timestamp() * msPerSecond;
+ RefPtr<JSONObject> data = TimelineRecordFactory::createEmbedderCallbackData(event.asString(InstrumentationEventArguments::CallbackName));
+ RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp, 0, TimelineRecordType::EmbedderCallback, data);
+ state.recordStack.addScopedRecord(record, TimelineRecordType::EmbedderCallback);
+}
+
+void InspectorTimelineAgent::onEmbedderCallbackEnd(const TraceEventDispatcher::TraceEvent& event)
+{
+ TimelineThreadState& state = threadState(event.threadIdentifier());
+ state.recordStack.closeScopedRecord(event.timestamp() * msPerSecond);
+}
+
+void InspectorTimelineAgent::addRecordToTimeline(PassRefPtr<TimelineEvent> record, double ts)
{
commitFrameRecord();
innerAddRecordToTimeline(record);
+ if (m_bufferedEvents && ts - m_lastProgressTimestamp > 300) {
+ m_lastProgressTimestamp = ts;
+ m_frontend->progress(m_bufferedEvents->length());
+ }
}
void InspectorTimelineAgent::innerAddRecordToTimeline(PassRefPtr<TimelineEvent> record)
{
if (m_recordStack.isEmpty()) {
+ TraceEventDispatcher::instance()->processBackgroundEvents();
sendEvent(record);
} else {
- setCounters(record.get());
TimelineRecordEntry& parent = m_recordStack.last();
parent.children->addItem(record);
+ if (m_state->getBoolean(TimelineAgentState::includeCounters))
+ parent.children->addItem(createCountersUpdate());
}
}
return info.usedJSHeapSize;
}
-void InspectorTimelineAgent::setCounters(TimelineEvent* record)
+PassRefPtr<TypeBuilder::Timeline::TimelineEvent> InspectorTimelineAgent::createCountersUpdate()
{
- if (!m_state->getBoolean(TimelineAgentState::includeCounters))
- return;
RefPtr<TypeBuilder::Timeline::Counters> counters = TypeBuilder::Timeline::Counters::create();
if (m_inspectorType == PageInspector) {
counters->setDocuments(InspectorCounters::counterValue(InspectorCounters::DocumentCounter));
counters->setJsEventListeners(InspectorCounters::counterValue(InspectorCounters::JSEventListenerCounter));
}
counters->setJsHeapSizeUsed(static_cast<double>(getUsedHeapSize()));
- record->setCounters(counters.release());
+ return TimelineRecordFactory::createGenericRecord(timestamp(), 0, TimelineRecordType::UpdateCounters, counters.release()->asObject());
}
-void InspectorTimelineAgent::setFrameIdentifier(TimelineEvent* record, Frame* frame)
+void InspectorTimelineAgent::setFrameIdentifier(TimelineEvent* record, LocalFrame* frame)
{
if (!frame || !m_pageAgent)
return;
void InspectorTimelineAgent::didCompleteCurrentRecord(const String& type)
{
// An empty stack could merely mean that the timeline agent was turned on in the middle of
- // an event. Don't treat as an error.
+ // an event. Don't treat as an error.
if (!m_recordStack.isEmpty()) {
if (m_platformInstrumentationClientInstalledAtStackDepth == m_recordStack.size()) {
m_platformInstrumentationClientInstalledAtStackDepth = 0;
PlatformInstrumentation::setClient(0);
}
- pushGCEventRecords();
TimelineRecordEntry entry = m_recordStack.last();
m_recordStack.removeLast();
+ while (entry.type != type && entry.skipWhenUnbalanced && !m_recordStack.isEmpty()) {
+ // Discard pending skippable entry, paste its children inplace.
+ if (entry.children)
+ m_recordStack.last().children->concat(entry.children);
+ entry = m_recordStack.last();
+ m_recordStack.removeLast();
+ }
ASSERT(entry.type == type);
entry.record->setChildren(entry.children);
- entry.record->setEndTime(timestamp());
- ptrdiff_t usedHeapSizeDelta = getUsedHeapSize() - entry.usedHeapSizeAtStart;
- if (usedHeapSizeDelta)
- entry.record->setUsedHeapSizeDelta(usedHeapSizeDelta);
- addRecordToTimeline(entry.record);
+ double ts = timestamp();
+ entry.record->setEndTime(ts);
+ addRecordToTimeline(entry.record, ts);
}
}
}
}
-InspectorTimelineAgent::InspectorTimelineAgent(InspectorPageAgent* pageAgent, InspectorDOMAgent* domAgent, InspectorOverlay* overlay, InspectorType type, InspectorClient* client)
+InspectorTimelineAgent::InspectorTimelineAgent(InspectorPageAgent* pageAgent, InspectorLayerTreeAgent* layerTreeAgent,
+ InspectorOverlay* overlay, InspectorType type, InspectorClient* client)
: InspectorBaseAgent<InspectorTimelineAgent>("Timeline")
, m_pageAgent(pageAgent)
- , m_domAgent(domAgent)
+ , m_layerTreeAgent(layerTreeAgent)
, m_frontend(0)
, m_client(client)
, m_overlay(overlay)
, m_platformInstrumentationClientInstalledAtStackDepth(0)
, m_imageBeingPainted(0)
, m_paintSetupStart(0)
- , m_styleRecalcElementCounter(0)
, m_mayEmitFirstPaint(false)
+ , m_lastProgressTimestamp(0)
{
}
-void InspectorTimelineAgent::appendRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, Frame* frame)
+void InspectorTimelineAgent::appendRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, LocalFrame* frame)
{
- pushGCEventRecords();
- RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp(), captureCallStack ? m_maxCallStackDepth : 0, type, data);
+ double ts = timestamp();
+ RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(ts, captureCallStack ? m_maxCallStackDepth : 0, type, data);
setFrameIdentifier(record.get(), frame);
- addRecordToTimeline(record.release());
+ addRecordToTimeline(record.release(), ts);
}
void InspectorTimelineAgent::sendEvent(PassRefPtr<TimelineEvent> record)
{
- if (m_bufferedEvents)
- m_bufferedEvents->addItem(record);
- else
- m_frontend->eventRecorded(record);
+ RefPtr<TimelineEvent> retain = record;
+ if (m_bufferedEvents) {
+ m_bufferedEvents->addItem(retain);
+ if (!m_liveEvents.contains(TimelineRecordFactory::type(retain.get())))
+ return;
+ }
+ m_frontend->eventRecorded(retain.release());
}
-void InspectorTimelineAgent::pushCurrentRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, Frame* frame, bool hasLowLevelDetails)
+void InspectorTimelineAgent::pushCurrentRecord(PassRefPtr<JSONObject> data, const String& type, bool captureCallStack, LocalFrame* frame, bool hasLowLevelDetails)
{
- pushGCEventRecords();
commitFrameRecord();
RefPtr<TimelineEvent> record = TimelineRecordFactory::createGenericRecord(timestamp(), captureCallStack ? m_maxCallStackDepth : 0, type, data.get());
setFrameIdentifier(record.get(), frame);
- m_recordStack.append(TimelineRecordEntry(record.release(), data, TypeBuilder::Array<TimelineEvent>::create(), type, getUsedHeapSize()));
+ m_recordStack.append(TimelineRecordEntry(record.release(), data, TypeBuilder::Array<TimelineEvent>::create(), type));
if (hasLowLevelDetails && !m_platformInstrumentationClientInstalledAtStackDepth && !PlatformInstrumentation::hasClient()) {
m_platformInstrumentationClientInstalledAtStackDepth = m_recordStack.size();
PlatformInstrumentation::setClient(this);
ThreadStateMap::iterator it = m_threadStates.find(thread);
if (it != m_threadStates.end())
return it->value;
- return m_threadStates.add(thread, TimelineThreadState(this)).iterator->value;
+ return m_threadStates.add(thread, TimelineThreadState(this)).storedValue->value;
}
void InspectorTimelineAgent::commitFrameRecord()
void InspectorTimelineAgent::localToPageQuad(const RenderObject& renderer, const LayoutRect& rect, FloatQuad* quad)
{
- Frame* frame = renderer.frame();
+ LocalFrame* frame = renderer.frame();
FrameView* view = frame->view();
FloatQuad absolute = renderer.localToAbsoluteQuad(FloatQuad(rect));
quad->setP1(view->contentsToRootView(roundedIntPoint(absolute.p1())));
long long InspectorTimelineAgent::nodeId(Node* node)
{
- return m_domAgent && node ? m_domAgent->backendNodeIdForNode(node, BackendNodeIdGroup) : 0;
+ return node ? InspectorNodeIds::idForNode(node) : 0;
}
long long InspectorTimelineAgent::nodeId(RenderObject* renderer)
{
- return nodeId(renderer->generatingNode());
-}
-
-void InspectorTimelineAgent::releaseNodeIds()
-{
- ErrorString unused;
- if (m_domAgent)
- m_domAgent->releaseBackendNodeIds(&unused, BackendNodeIdGroup);
+ return InspectorNodeIds::idForNode(renderer->generatingNode());
}
double InspectorTimelineAgent::timestamp()
{
- return m_timeConverter.fromMonotonicallyIncreasingTime(WTF::monotonicallyIncreasingTime());
+ return WTF::monotonicallyIncreasingTime() * msPerSecond;
}
-FrameHost* InspectorTimelineAgent::frameHost() const
+LocalFrame* InspectorTimelineAgent::mainFrame() const
{
- if (!m_pageAgent || !m_pageAgent->page())
+ if (!m_pageAgent)
return 0;
- return &m_pageAgent->page()->frameHost();
+ return m_pageAgent->mainFrame();
}
PassRefPtr<TimelineEvent> InspectorTimelineAgent::createRecordForEvent(const TraceEventDispatcher::TraceEvent& event, const String& type, PassRefPtr<JSONObject> data)
{
- double timeestamp = m_timeConverter.fromMonotonicallyIncreasingTime(event.timestamp());
+ double timeestamp = event.timestamp() * msPerSecond;
return TimelineRecordFactory::createBackgroundRecord(timeestamp, String::number(event.threadIdentifier()), type, data);
}
+void InspectorTimelineAgent::setLiveEvents(const String& liveEvents)
+{
+ m_liveEvents.clear();
+ if (liveEvents.isNull() || liveEvents.isEmpty())
+ return;
+ Vector<String> eventList;
+ liveEvents.split(",", eventList);
+ for (Vector<String>::iterator it = eventList.begin(); it != eventList.end(); ++it)
+ m_liveEvents.add(*it);
+}
+
TimelineRecordStack::TimelineRecordStack(InspectorTimelineAgent* timelineAgent)
: m_timelineAgent(timelineAgent)
{
projects / platform / framework / web / crosswalk.git / blobdiff