DevTools: implement console.timeline/timelineEnd.

Source/core/inspector/InspectorTimelineAgent.cpp

Index: Source/core/inspector/InspectorTimelineAgent.cpp
diff --git a/Source/core/inspector/InspectorTimelineAgent.cpp b/Source/core/inspector/InspectorTimelineAgent.cpp
index 2b5b5df945c7ca93eb9a0290d8d16a4d006bba99..a385353b5843798caccc8138e3f385ca4f2f54ec 100644
--- a/Source/core/inspector/InspectorTimelineAgent.cpp
+++ b/Source/core/inspector/InspectorTimelineAgent.cpp
@@ -48,6 +48,7 @@
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
+#include "core/page/PageConsole.h"
 #include "core/platform/MemoryUsageSupport.h"
 #include "core/platform/chromium/TraceEvent.h"
 #include "core/platform/network/ResourceRequest.h"
@@ -60,7 +61,7 @@
 namespace WebCore {
 
 namespace TimelineAgentState {
-static const char timelineAgentEnabled[] = "timelineAgentEnabled";
+static const char startedFromProtocol[] = "startedFromProtocol";
 static const char timelineMaxCallStackDepth[] = "timelineMaxCallStackDepth";
 static const char includeDomCounters[] = "includeDomCounters";
 static const char includeNativeMemoryStatistics[] = "includeNativeMemoryStatistics";
@@ -195,7 +196,7 @@ void InspectorTimelineAgent::clearFrontend()
 
 void InspectorTimelineAgent::restore()
 {
-    if (m_state->getBoolean(TimelineAgentState::timelineAgentEnabled)) {
+    if (m_state->getBoolean(TimelineAgentState::startedFromProtocol)) {
         m_maxCallStackDepth = m_state->getLong(TimelineAgentState::timelineMaxCallStackDepth);
         ErrorString error;
         bool includeDomCounters = m_state->getBoolean(TimelineAgentState::includeDomCounters);
@@ -208,6 +209,10 @@ void InspectorTimelineAgent::start(ErrorString*, const int* maxCallStackDepth, c
 {
     if (!m_frontend)
         return;
+    m_state->setBoolean(TimelineAgentState::startedFromProtocol, true);
+
+    if (m_isStarted)
+        return;
 
     releaseNodeIds();
     if (maxCallStackDepth && *maxCallStackDepth >= 0)
@@ -217,19 +222,34 @@ void InspectorTimelineAgent::start(ErrorString*, const int* maxCallStackDepth, c
     m_state->setLong(TimelineAgentState::timelineMaxCallStackDepth, m_maxCallStackDepth);
     m_state->setBoolean(TimelineAgentState::includeDomCounters, includeDomCounters && *includeDomCounters);
     m_state->setBoolean(TimelineAgentState::includeNativeMemoryStatistics, includeNativeMemoryStatistics && *includeNativeMemoryStatistics);
-    m_timeConverter.reset();
+    innerStart(false);
+}
 
+void InspectorTimelineAgent::innerStart(bool fromConsole)
+{
+    if (m_isStarted)
+        return;
+    m_isStarted = true;
+
+    m_timeConverter.reset();
     m_instrumentingAgents->setInspectorTimelineAgent(this);
     ScriptGCEvent::addEventListener(this);
-    m_state->setBoolean(TimelineAgentState::timelineAgentEnabled, true);
     if (m_client && m_pageAgent)
         m_traceEventProcessor = adoptRef(new TimelineTraceEventProcessor(m_weakFactory.createWeakPtr(), m_client));
+    m_frontend->started(&fromConsole);
 }
 
 void InspectorTimelineAgent::stop(ErrorString*)
 {
-    if (!m_state->getBoolean(TimelineAgentState::timelineAgentEnabled))
+    innerStop(false);
+    m_state->setBoolean(TimelineAgentState::startedFromProtocol, false);
+}
+
+void InspectorTimelineAgent::innerStop(bool fromConsole)
+{
+    if (!m_isStarted)
         return;
+    m_isStarted = false;
 
     if (m_traceEventProcessor) {
         m_traceEventProcessor->shutdown();
@@ -242,7 +262,13 @@ void InspectorTimelineAgent::stop(ErrorString*)
     clearRecordStack();
     m_gcEvents.clear();
 
-    m_state->setBoolean(TimelineAgentState::timelineAgentEnabled, false);
+    for (size_t i = 0; i < m_consoleTimelines.size(); ++i) {
+        String message = String::format("Timeline '%s' terminated.", m_consoleTimelines[i].utf8().data());
+        page()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message);
+    }
+    m_consoleTimelines.clear();
+
+    m_frontend->stopped(&fromConsole);
 }
 
 void InspectorTimelineAgent::didBeginFrame()
@@ -549,23 +575,47 @@ void InspectorTimelineAgent::didFailLoading(unsigned long identifier, DocumentLo
     didFinishLoadingResource(identifier, true, 0, loader->frame());
 }
 
-void InspectorTimelineAgent::consoleTimeStamp(ScriptExecutionContext* context, PassRefPtr<ScriptArguments> arguments)
+void InspectorTimelineAgent::consoleTimeStamp(ScriptExecutionContext* context, const String& title)
 {
-    String message;
-    arguments->getFirstArgumentAsString(message);
-    appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeStamp, true, frameForScriptExecutionContext(context));
+    appendRecord(TimelineRecordFactory::createTimeStampData(title), TimelineRecordType::TimeStamp, true, frameForScriptExecutionContext(context));
 }
 
-void InspectorTimelineAgent::startConsoleTiming(ScriptExecutionContext* context, const String& message)
+void InspectorTimelineAgent::consoleTime(ScriptExecutionContext* context, const String& message)
 {
     appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::Time, true, frameForScriptExecutionContext(context));
 }
 
-void InspectorTimelineAgent::stopConsoleTiming(ScriptExecutionContext* context, const String& message, PassRefPtr<ScriptCallStack> stack)
+void InspectorTimelineAgent::consoleTimeEnd(ScriptExecutionContext* context, const String& message, ScriptState*)
 {
     appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeEnd, true, frameForScriptExecutionContext(context));
 }
 
+void InspectorTimelineAgent::consoleTimeline(ScriptExecutionContext* context, const String& title, ScriptState* state)
+{
+    String message = String::format("Timeline '%s' started.", title.utf8().data());
+    page()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+    m_consoleTimelines.append(title);

[yurys, 2013/09/06 07:56:45]

What is the expected behavior when same timeline is started twice?

[pfeldman, 2013/09/06 16:10:30]

console.timeline("one")
console.timeline("one")
console.timelineEnd("one")
console.timelineEnd("one")

is a valid supported case.

+    innerStart(true);
+    appendRecord(TimelineRecordFactory::createTimeStampData(title), TimelineRecordType::TimeStamp, true, frameForScriptExecutionContext(context));
+}
+
+void InspectorTimelineAgent::consoleTimelineEnd(ScriptExecutionContext* context, const String& title, ScriptState* state)
+{
+    size_t index = m_consoleTimelines.find(title);
+    if (index == notFound) {
+        String message = String::format("Timeline '%s' was not started.", title.utf8().data());
+        page()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+        return;
+    }
+
+    appendRecord(TimelineRecordFactory::createTimeStampData(title), TimelineRecordType::TimeStamp, true, frameForScriptExecutionContext(context));
+    m_consoleTimelines.remove(index);
+    if (!m_consoleTimelines.size() && !m_state->getBoolean(TimelineAgentState::startedFromProtocol))
+        innerStop(true);
+
+    String message = String::format("Timeline '%s' finished.", title.utf8().data());
+    page()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, 0, state);
+}
 
 void InspectorTimelineAgent::domContentLoadedEventFired(Frame* frame)
 {
@@ -729,6 +779,7 @@ InspectorTimelineAgent::InspectorTimelineAgent(InstrumentingAgents* instrumentin
     , m_weakFactory(this)
     , m_styleRecalcElementCounter(0)
     , m_layerTreeId(0)
+    , m_isStarted(false)
 {
 }