Home | History | Annotate | Download | only in inspector 
      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/InspectorHeapProfilerAgent.h"
     33 
     34 #include "bindings/core/v8/ScriptProfiler.h"
     35 #include "core/inspector/InjectedScript.h"
     36 #include "core/inspector/InjectedScriptHost.h"
     37 #include "core/inspector/InspectorState.h"
     38 #include "platform/Timer.h"
     39 #include "wtf/CurrentTime.h"
     40 
     41 namespace blink {
     42 
     43 typedef uint32_t SnapshotObjectId;
     44 
     45 namespace HeapProfilerAgentState {
     46 static const char heapProfilerEnabled[] = "heapProfilerEnabled";
     47 static const char heapObjectsTrackingEnabled[] = "heapObjectsTrackingEnabled";
     48 static const char allocationTrackingEnabled[] = "allocationTrackingEnabled";
     49 }
     50 
     51 class InspectorHeapProfilerAgent::HeapStatsUpdateTask FINAL : public NoBaseWillBeGarbageCollectedFinalized<InspectorHeapProfilerAgent::HeapStatsUpdateTask> {
     52 public:
     53     explicit HeapStatsUpdateTask(InspectorHeapProfilerAgent*);
     54     void startTimer();
     55     void resetTimer() { m_timer.stop(); }
     56     void onTimer(Timer<HeapStatsUpdateTask>*);
     57     void trace(Visitor*);
     58 
     59 private:
     60     RawPtrWillBeMember<InspectorHeapProfilerAgent> m_heapProfilerAgent;
     61     Timer<HeapStatsUpdateTask> m_timer;
     62 };
     63 
     64 PassOwnPtrWillBeRawPtr<InspectorHeapProfilerAgent> InspectorHeapProfilerAgent::create(InjectedScriptManager* injectedScriptManager)
     65 {
     66     return adoptPtrWillBeNoop(new InspectorHeapProfilerAgent(injectedScriptManager));
     67 }
     68 
     69 InspectorHeapProfilerAgent::InspectorHeapProfilerAgent(InjectedScriptManager* injectedScriptManager)
     70     : InspectorBaseAgent<InspectorHeapProfilerAgent>("HeapProfiler")
     71     , m_injectedScriptManager(injectedScriptManager)
     72     , m_frontend(0)
     73     , m_nextUserInitiatedHeapSnapshotNumber(1)
     74 {
     75 }
     76 
     77 InspectorHeapProfilerAgent::~InspectorHeapProfilerAgent()
     78 {
     79 }
     80 
     81 void InspectorHeapProfilerAgent::setFrontend(InspectorFrontend* frontend)
     82 {
     83     m_frontend = frontend->heapprofiler();
     84 }
     85 
     86 void InspectorHeapProfilerAgent::clearFrontend()
     87 {
     88     m_frontend = 0;
     89 
     90     m_nextUserInitiatedHeapSnapshotNumber = 1;
     91     stopTrackingHeapObjectsInternal();
     92     m_injectedScriptManager->injectedScriptHost()->clearInspectedObjects();
     93 
     94     ErrorString error;
     95     disable(&error);
     96 }
     97 
     98 void InspectorHeapProfilerAgent::restore()
     99 {
    100     if (m_state->getBoolean(HeapProfilerAgentState::heapProfilerEnabled))
    101         m_frontend->resetProfiles();
    102     if (m_state->getBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled))
    103         startTrackingHeapObjectsInternal(m_state->getBoolean(HeapProfilerAgentState::allocationTrackingEnabled));
    104 }
    105 
    106 void InspectorHeapProfilerAgent::collectGarbage(blink::ErrorString*)
    107 {
    108     ScriptProfiler::collectGarbage();
    109 }
    110 
    111 InspectorHeapProfilerAgent::HeapStatsUpdateTask::HeapStatsUpdateTask(InspectorHeapProfilerAgent* heapProfilerAgent)
    112     : m_heapProfilerAgent(heapProfilerAgent)
    113     , m_timer(this, &HeapStatsUpdateTask::onTimer)
    114 {
    115 }
    116 
    117 void InspectorHeapProfilerAgent::HeapStatsUpdateTask::onTimer(Timer<HeapStatsUpdateTask>*)
    118 {
    119     // The timer is stopped on m_heapProfilerAgent destruction,
    120     // so this method will never be called after m_heapProfilerAgent has been destroyed.
    121     m_heapProfilerAgent->requestHeapStatsUpdate();
    122 }
    123 
    124 void InspectorHeapProfilerAgent::HeapStatsUpdateTask::startTimer()
    125 {
    126     ASSERT(!m_timer.isActive());
    127     m_timer.startRepeating(0.05, FROM_HERE);
    128 }
    129 
    130 void InspectorHeapProfilerAgent::HeapStatsUpdateTask::trace(Visitor* visitor)
    131 {
    132     visitor->trace(m_heapProfilerAgent);
    133 }
    134 
    135 class InspectorHeapProfilerAgent::HeapStatsStream FINAL : public ScriptProfiler::OutputStream {
    136 public:
    137     HeapStatsStream(InspectorHeapProfilerAgent* heapProfilerAgent)
    138         : m_heapProfilerAgent(heapProfilerAgent)
    139     {
    140     }
    141 
    142     virtual void write(const uint32_t* chunk, const int size) OVERRIDE
    143     {
    144         ASSERT(chunk);
    145         ASSERT(size > 0);
    146         m_heapProfilerAgent->pushHeapStatsUpdate(chunk, size);
    147     }
    148 private:
    149     InspectorHeapProfilerAgent* m_heapProfilerAgent;
    150 };
    151 
    152 void InspectorHeapProfilerAgent::startTrackingHeapObjects(ErrorString*, const bool* trackAllocations)
    153 {
    154     m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, true);
    155     bool allocationTrackingEnabled = asBool(trackAllocations);
    156     m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, allocationTrackingEnabled);
    157     startTrackingHeapObjectsInternal(allocationTrackingEnabled);
    158 }
    159 
    160 void InspectorHeapProfilerAgent::requestHeapStatsUpdate()
    161 {
    162     if (!m_frontend)
    163         return;
    164     HeapStatsStream stream(this);
    165     SnapshotObjectId lastSeenObjectId = ScriptProfiler::requestHeapStatsUpdate(&stream);
    166     m_frontend->lastSeenObjectId(lastSeenObjectId, WTF::currentTimeMS());
    167 }
    168 
    169 void InspectorHeapProfilerAgent::pushHeapStatsUpdate(const uint32_t* const data, const int size)
    170 {
    171     if (!m_frontend)
    172         return;
    173     RefPtr<TypeBuilder::Array<int> > statsDiff = TypeBuilder::Array<int>::create();
    174     for (int i = 0; i < size; ++i)
    175         statsDiff->addItem(data[i]);
    176     m_frontend->heapStatsUpdate(statsDiff.release());
    177 }
    178 
    179 void InspectorHeapProfilerAgent::stopTrackingHeapObjects(ErrorString* error, const bool* reportProgress)
    180 {
    181     if (!m_heapStatsUpdateTask) {
    182         *error = "Heap object tracking is not started.";
    183         return;
    184     }
    185     requestHeapStatsUpdate();
    186     takeHeapSnapshot(error, reportProgress);
    187     stopTrackingHeapObjectsInternal();
    188 }
    189 
    190 void InspectorHeapProfilerAgent::startTrackingHeapObjectsInternal(bool trackAllocations)
    191 {
    192     if (m_heapStatsUpdateTask)
    193         return;
    194     ScriptProfiler::startTrackingHeapObjects(trackAllocations);
    195     m_heapStatsUpdateTask = adoptPtrWillBeNoop(new HeapStatsUpdateTask(this));
    196     m_heapStatsUpdateTask->startTimer();
    197 }
    198 
    199 void InspectorHeapProfilerAgent::stopTrackingHeapObjectsInternal()
    200 {
    201     if (!m_heapStatsUpdateTask)
    202         return;
    203     ScriptProfiler::stopTrackingHeapObjects();
    204     m_heapStatsUpdateTask->resetTimer();
    205     m_heapStatsUpdateTask.clear();
    206     m_state->setBoolean(HeapProfilerAgentState::heapObjectsTrackingEnabled, false);
    207     m_state->setBoolean(HeapProfilerAgentState::allocationTrackingEnabled, false);
    208 }
    209 
    210 void InspectorHeapProfilerAgent::enable(ErrorString*)
    211 {
    212     m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, true);
    213 }
    214 
    215 void InspectorHeapProfilerAgent::disable(ErrorString* error)
    216 {
    217     stopTrackingHeapObjectsInternal();
    218     ScriptProfiler::clearHeapObjectIds();
    219     m_state->setBoolean(HeapProfilerAgentState::heapProfilerEnabled, false);
    220 }
    221 
    222 void InspectorHeapProfilerAgent::takeHeapSnapshot(ErrorString* errorString, const bool* reportProgress)
    223 {
    224     class HeapSnapshotProgress FINAL : public ScriptProfiler::HeapSnapshotProgress {
    225     public:
    226         explicit HeapSnapshotProgress(InspectorFrontend::HeapProfiler* frontend)
    227             : m_frontend(frontend) { }
    228         virtual void Start(int totalWork) OVERRIDE
    229         {
    230             m_totalWork = totalWork;
    231         }
    232         virtual void Worked(int workDone) OVERRIDE
    233         {
    234             if (m_frontend) {
    235                 m_frontend->reportHeapSnapshotProgress(workDone, m_totalWork, 0);
    236                 m_frontend->flush();
    237             }
    238         }
    239         virtual void Done() OVERRIDE
    240         {
    241             const bool finished = true;
    242             if (m_frontend) {
    243                 m_frontend->reportHeapSnapshotProgress(m_totalWork, m_totalWork, &finished);
    244                 m_frontend->flush();
    245             }
    246         }
    247         virtual bool isCanceled() OVERRIDE { return false; }
    248     private:
    249         InspectorFrontend::HeapProfiler* m_frontend;
    250         int m_totalWork;
    251     };
    252 
    253     String title = "Snapshot " + String::number(m_nextUserInitiatedHeapSnapshotNumber++);
    254     HeapSnapshotProgress progress(asBool(reportProgress) ? m_frontend : 0);
    255     RefPtr<ScriptHeapSnapshot> snapshot = ScriptProfiler::takeHeapSnapshot(title, &progress);
    256     if (!snapshot) {
    257         *errorString = "Failed to take heap snapshot";
    258         return;
    259     }
    260 
    261     class OutputStream : public ScriptHeapSnapshot::OutputStream {
    262     public:
    263         explicit OutputStream(InspectorFrontend::HeapProfiler* frontend)
    264             : m_frontend(frontend) { }
    265         void Write(const String& chunk)
    266         {
    267             m_frontend->addHeapSnapshotChunk(chunk);
    268             m_frontend->flush();
    269         }
    270         void Close() { }
    271     private:
    272         InspectorFrontend::HeapProfiler* m_frontend;
    273     };
    274 
    275     if (m_frontend) {
    276         OutputStream stream(m_frontend);
    277         snapshot->writeJSON(&stream);
    278     }
    279 }
    280 
    281 void InspectorHeapProfilerAgent::getObjectByHeapObjectId(ErrorString* error, const String& heapSnapshotObjectId, const String* objectGroup, RefPtr<TypeBuilder::Runtime::RemoteObject>& result)
    282 {
    283     bool ok;
    284     unsigned id = heapSnapshotObjectId.toUInt(&ok);
    285     if (!ok) {
    286         *error = "Invalid heap snapshot object id";
    287         return;
    288     }
    289     ScriptValue heapObject = ScriptProfiler::objectByHeapObjectId(id);
    290     if (heapObject.isEmpty()) {
    291         *error = "Object is not available";
    292         return;
    293     }
    294     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(heapObject.scriptState());
    295     if (injectedScript.isEmpty()) {
    296         *error = "Object is not available. Inspected context is gone";
    297         return;
    298     }
    299     result = injectedScript.wrapObject(heapObject, objectGroup ? *objectGroup : "");
    300     if (!result)
    301         *error = "Failed to wrap object";
    302 }
    303 
    304 void InspectorHeapProfilerAgent::getHeapObjectId(ErrorString* errorString, const String& objectId, String* heapSnapshotObjectId)
    305 {
    306     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
    307     if (injectedScript.isEmpty()) {
    308         *errorString = "Inspected context has gone";
    309         return;
    310     }
    311     ScriptValue value = injectedScript.findObjectById(objectId);
    312     ScriptState::Scope scope(injectedScript.scriptState());
    313     if (value.isEmpty() || value.isUndefined()) {
    314         *errorString = "Object with given id not found";
    315         return;
    316     }
    317     unsigned id = ScriptProfiler::getHeapObjectId(value);
    318     *heapSnapshotObjectId = String::number(id);
    319 }
    320 
    321 void InspectorHeapProfilerAgent::trace(Visitor* visitor)
    322 {
    323     visitor->trace(m_injectedScriptManager);
    324     visitor->trace(m_heapStatsUpdateTask);
    325     InspectorBaseAgent::trace(visitor);
    326 }
    327 
    328 } // namespace blink
    329 
    330