DevTools: [HeapProfiler] Provide API for heap objects tracking info.

Source/core/inspector/InspectorHeapProfilerAgent.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 19 matching lines @@
 
 #include "config.h"
 #include "InspectorHeapProfilerAgent.h"
 
 #include "InjectedScript.h"
 #include "InjectedScriptHost.h"
 #include "InspectorState.h"
 #include "InstrumentingAgents.h"
 #include "ScriptProfiler.h"
 #include "WebCoreMemoryInstrumentation.h"
+#include "core/platform/Timer.h"
+#include <wtf/CurrentTime.h>
 #include <wtf/MemoryInstrumentationHashMap.h>
 
 namespace WebCore {
 
 namespace HeapProfilerAgentState {
 static const char profileHeadersRequested[] = "profileHeadersRequested";
 }
 
 static const char* const UserInitiatedProfileNameHeap = "org.webkit.profiles.user-initiated";
 
+class InspectorHeapProfilerAgent::HeapStatsUpdateTask {
+public:
+    HeapStatsUpdateTask(InspectorHeapProfilerAgent*);
+    void startTimer();
+    void resetTimer() { m_timer.stop(); }
+    void onTimer(Timer<HeapStatsUpdateTask>*);
+
+private:
+    InspectorHeapProfilerAgent* m_heapProfilerAgent;
+    Timer<HeapStatsUpdateTask> m_timer;
+};
+
 PassOwnPtr<InspectorHeapProfilerAgent> InspectorHeapProfilerAgent::create(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* inspectorState, InjectedScriptManager* injectedScriptManager)
 {
     return adoptPtr(new InspectorHeapProfilerAgent(instrumentingAgents, inspectorState, injectedScriptManager));
 }
 
 InspectorHeapProfilerAgent::InspectorHeapProfilerAgent(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* inspectorState, InjectedScriptManager* injectedScriptManager)
     : InspectorBaseAgent<InspectorHeapProfilerAgent>("HeapProfiler", instrumentingAgents, inspectorState)
     , m_injectedScriptManager(injectedScriptManager)
     , m_frontend(0)
     , m_nextUserInitiatedHeapSnapshotNumber(1)
 {
     m_instrumentingAgents->setInspectorHeapProfilerAgent(this);
 }
 
 InspectorHeapProfilerAgent::~InspectorHeapProfilerAgent()
 {
     m_instrumentingAgents->setInspectorHeapProfilerAgent(0);
 }
 
 void InspectorHeapProfilerAgent::clearProfiles(ErrorString*)
 {
     m_snapshots.clear();
     m_nextUserInitiatedHeapSnapshotNumber = 1;
     resetFrontendProfiles();
     m_injectedScriptManager->injectedScriptHost()->clearInspectedObjects();
 }
 
 void InspectorHeapProfilerAgent::resetFrontendProfiles()
 {
+    stopTrackingHeapObjects(0);
     if (!m_frontend)
         return;
     if (!m_state->getBoolean(HeapProfilerAgentState::profileHeadersRequested))
         return;
     if (m_snapshots.isEmpty())
         m_frontend->resetProfiles();
 }
 
 void InspectorHeapProfilerAgent::setFrontend(InspectorFrontend* frontend)
 {
@@ skipping 18 matching lines @@
 
 PassRefPtr<TypeBuilder::HeapProfiler::ProfileHeader> InspectorHeapProfilerAgent::createSnapshotHeader(const ScriptHeapSnapshot& snapshot)
 {
     RefPtr<TypeBuilder::HeapProfiler::ProfileHeader> header = TypeBuilder::HeapProfiler::ProfileHeader::create()
         .setUid(snapshot.uid())
         .setTitle(snapshot.title());
     header->setMaxJSObjectId(snapshot.maxSnapshotJSObjectId());
     return header.release();
 }
 
+InspectorHeapProfilerAgent::HeapStatsUpdateTask::HeapStatsUpdateTask(InspectorHeapProfilerAgent* heapProfilerAgent)
+    : m_heapProfilerAgent(heapProfilerAgent)
+    , m_timer(this, &HeapStatsUpdateTask::onTimer)
+{
+}
+
+void InspectorHeapProfilerAgent::HeapStatsUpdateTask::onTimer(Timer<HeapStatsUpdateTask>*)
+{
+    // The timer is stopped on m_heapProfilerAgent destruction,
+    // so this method will never be called after m_heapProfilerAgent has been destroyed.
+    m_heapProfilerAgent->requestHeapStatsUpdate();
+}
+
+void InspectorHeapProfilerAgent::HeapStatsUpdateTask::startTimer()
+{
+    ASSERT(!m_timer.isActive());
+    m_timer.startRepeating(0.05);
+}
+
+class InspectorHeapProfilerAgent::HeapStatsStream : public ScriptProfiler::OutputStream {
+public:
+    HeapStatsStream(InspectorHeapProfilerAgent* heapProfilerAgent)
+        : m_heapProfilerAgent(heapProfilerAgent)
+    {
+    }
+
+    virtual void write(const uint32_t* chunk, const int size) OVERRIDE
+    {
+        ASSERT(chunk);
+        ASSERT(size > 0);
+        m_heapProfilerAgent->pushHeapStatsUpdate(chunk, size);
+    }
+private:
+    InspectorHeapProfilerAgent* m_heapProfilerAgent;
+};
+
+void InspectorHeapProfilerAgent::startTrackingHeapObjects(ErrorString*)
+{
+    if (m_heapStatsUpdateTask)
+        return;
+    ScriptProfiler::startTrackingHeapObjects();
+    m_heapStatsUpdateTask = adoptPtr(new HeapStatsUpdateTask(this));
+    m_heapStatsUpdateTask->startTimer();
+}
+
+void InspectorHeapProfilerAgent::requestHeapStatsUpdate()
+{
+    if (!m_frontend)
+        return;
+    HeapStatsStream stream(this);
+    SnapshotObjectId lastSeenObjectId = ScriptProfiler::requestHeapStatsUpdate(&stream);
+    m_frontend->lastSeenObjectId(lastSeenObjectId, WTF::currentTimeMS());
+}
+
+void InspectorHeapProfilerAgent::pushHeapStatsUpdate(const uint32_t* const data, const int size)
+{
+    if (!m_frontend)
+        return;
+    RefPtr<TypeBuilder::Array<int> > statsDiff = TypeBuilder::Array<int>::create();
+    for (int i = 0; i < size; ++i)
+        statsDiff->addItem(data[i]);
+    m_frontend->heapStatsUpdate(statsDiff.release());
+}
+
+void InspectorHeapProfilerAgent::stopTrackingHeapObjects(ErrorString*)
+{
+    if (!m_heapStatsUpdateTask)
+        return;
+    ScriptProfiler::stopTrackingHeapObjects();
+    m_heapStatsUpdateTask->resetTimer();
+    m_heapStatsUpdateTask.clear();
+}
+
 void InspectorHeapProfilerAgent::getProfileHeaders(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::HeapProfiler::ProfileHeader> >& headers)
 {
     m_state->setBoolean(HeapProfilerAgentState::profileHeadersRequested, true);
     headers = TypeBuilder::Array<TypeBuilder::HeapProfiler::ProfileHeader>::create();
 
     IdToHeapSnapshotMap::iterator snapshotsEnd = m_snapshots.end();
     for (IdToHeapSnapshotMap::iterator it = m_snapshots.begin(); it != snapshotsEnd; ++it)
         headers->addItem(createSnapshotHeader(*it->value));
 }
 
@@ skipping 107 matching lines @@
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::InspectorProfilerAgent);
     InspectorBaseAgent<InspectorHeapProfilerAgent>::reportMemoryUsage(memoryObjectInfo);
     info.addMember(m_injectedScriptManager, "injectedScriptManager");
     info.addWeakPointer(m_frontend);
     info.addMember(m_snapshots, "snapshots");
 }
 
 } // namespace WebCore