Timeline: produce session cookie when timeline is started

Source/core/inspector/InspectorTimelineAgent.cpp

 /*
 * Copyright (C) 2013 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
 #include "core/page/Page.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderView.h"
 #include "core/xml/XMLHttpRequest.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/network/ResourceRequest.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DateMath.h"
+#include "wtf/ProcessID.h"
 
 namespace WebCore {
 
 namespace TimelineAgentState {
 static const char enabled[] = "enabled";
 static const char started[] = "started";
 static const char startedFromProtocol[] = "startedFromProtocol";
 static const char timelineMaxCallStackDepth[] = "timelineMaxCallStackDepth";
 static const char includeCounters[] = "includeCounters";
 static const char includeGPUEvents[] = "includeGPUEvents";
 static const char bufferEvents[] = "bufferEvents";
 static const char liveEvents[] = "liveEvents";
+static const char sessionId[] = "sessionId";
 static const char traceEventCategoryFilter[] = "traceEventCategoryFilter";
 }
 
 // Must be kept in sync with WebInspector.TimelineModel.RecordType in TimelineModel.js
 namespace TimelineRecordType {
 static const char Program[] = "Program";
 
 static const char EventDispatch[] = "EventDispatch";
 static const char ScheduleStyleRecalculation[] = "ScheduleStyleRecalculation";
 static const char RecalculateStyles[] = "RecalculateStyles";
@@ skipping 248 matching lines @@
     }
 
     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 : "");
+    initializeSessionId();
 
     innerStart();
     bool fromConsole = false;
-    m_frontend->started(&fromConsole);
+    m_frontend->started(sessionId(), &fromConsole);
 }
 
 bool InspectorTimelineAgent::isStarted()
 {
     return m_state->getBoolean(TimelineAgentState::started);
 }
 
 void InspectorTimelineAgent::innerStart()
 {
     if (m_overlay)
         m_overlay->startedRecordingProfile();
     m_state->setBoolean(TimelineAgentState::started, true);
     String traceEventCategoryFilter = m_state->getString(TimelineAgentState::traceEventCategoryFilter);
     if (!traceEventCategoryFilter.isEmpty()) {
         m_client->enableTracing(traceEventCategoryFilter);
         m_disableTracingOnStop = true;
     } else {
         m_disableTracingOnStop = false;
     }
     m_instrumentingAgents->setInspectorTimelineAgent(this);
     ScriptGCEvent::addEventListener(this);
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "TimelineStarted", "sessionId", sessionId().utf8());
+    if (m_layerTreeId) {

[pfeldman, 2014/04/22 17:59:50]

call setLayerTreeId instead?

+        TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "SetLayerTreeId", "sessionId", sessionId().utf8(), "layerTreeId", m_layerTreeId);
+    }
     if (m_client) {
         TraceEventDispatcher* dispatcher = TraceEventDispatcher::instance();
         dispatcher->addListener(InstrumentationEvents::BeginFrame, TRACE_EVENT_PHASE_INSTANT, this, &InspectorTimelineAgent::onBeginImplSideFrame, m_client);
         dispatcher->addListener(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_BEGIN, this, &InspectorTimelineAgent::onPaintSetupBegin, m_client);
         dispatcher->addListener(InstrumentationEvents::PaintSetup, TRACE_EVENT_PHASE_END, this, &InspectorTimelineAgent::onPaintSetupEnd, 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);
@@ skipping 12 matching lines @@
             m_client->startGPUEventsRecording();
         }
     }
 }
 
 void InspectorTimelineAgent::stop(ErrorString* errorString, RefPtr<TypeBuilder::Array<TimelineEvent> >& events)
 {
     m_state->setBoolean(TimelineAgentState::startedFromProtocol, false);
     m_state->setBoolean(TimelineAgentState::bufferEvents, false);
     m_state->setString(TimelineAgentState::liveEvents, "");
+    m_state->setString(TimelineAgentState::sessionId, "");
 
     if (!isStarted()) {
         *errorString = "Timeline was not started";
         return;
     }
     innerStop(false);
     if (m_bufferedEvents)
         events = m_bufferedEvents.release();
     m_liveEvents.clear();
 }
@@ skipping 28 matching lines @@
         String message = String::format("Timeline '%s' terminated.", m_consoleTimelines[i].utf8().data());
         mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message);
     }
     m_consoleTimelines.clear();
 
     m_frontend->stopped(&fromConsole);
     if (m_overlay)
         m_overlay->finishedRecordingProfile();
 }
 
+String InspectorTimelineAgent::sessionId() const
+{
+    return m_state->getString(TimelineAgentState::sessionId);
+}
+
+void InspectorTimelineAgent::initializeSessionId()
+{
+    static unsigned lastTimelineSessionId;
+    String token = String::number(getCurrentProcessID()) + "." + String::number(++lastTimelineSessionId);

[yurys, 2014/04/23 07:05:38]

What if pid is reused after a few navigations? Generating this id in the browser
process would be more reliable.

+    m_state->setString(TimelineAgentState::sessionId, token);
+}
+
+void InspectorTimelineAgent::setLayerTreeId(int layerTreeId)
+{
+    m_layerTreeId = layerTreeId;
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "setLayerTreeId", "sessionId", sessionId().utf8(), "layerTreeId", m_layerTreeId);

[yurys, 2014/04/23 07:05:38]

Are we going to leave this instrumentation here after migrating to trace events
as Timeline backend?

+}
+
 void InspectorTimelineAgent::didBeginFrame(int frameId)
 {
     TraceEventDispatcher::instance()->processBackgroundEvents();
     m_pendingFrameRecord = TimelineRecordFactory::createGenericRecord(timestamp(), 0, TimelineRecordType::BeginFrame, TimelineRecordFactory::createFrameData(frameId));
 }
 
 void InspectorTimelineAgent::didCancelFrame()
 {
     m_pendingFrameRecord.clear();
 }
@@ skipping 364 matching lines @@
 
 void InspectorTimelineAgent::consoleTimeline(ExecutionContext* context, const String& title, ScriptState* state)
 {
     if (!m_state->getBoolean(TimelineAgentState::enabled))
         return;
 
     String message = String::format("Timeline '%s' started.", title.utf8().data());
     mainFrame()->console().addMessage(ConsoleAPIMessageSource, DebugMessageLevel, message, String(), 0, 0, nullptr, state);
     m_consoleTimelines.append(title);
     if (!isStarted()) {
+        initializeSessionId();
         innerStart();
         bool fromConsole = true;
-        m_frontend->started(&fromConsole);
+        m_frontend->started(sessionId(), &fromConsole);
     }
     appendRecord(TimelineRecordFactory::createTimeStampData(message), TimelineRecordType::TimeStamp, true, frameForExecutionContext(context));
 }
 
 void InspectorTimelineAgent::consoleTimelineEnd(ExecutionContext* context, const String& title, ScriptState* state)
 {
     if (!m_state->getBoolean(TimelineAgentState::enabled))
         return;
 
     size_t index = m_consoleTimelines.find(title);
@@ skipping 518 matching lines @@
 
 #ifndef NDEBUG
 bool TimelineRecordStack::isOpenRecordOfType(const String& type)
 {
     return !m_stack.isEmpty() && m_stack.last().type == type;
 }
 #endif
 
 } // namespace WebCore