LCOV - code coverage report
Current view: top level - out/Release/gen/src/inspector/protocol - HeapProfiler.h (source / functions) Hit Total Coverage
Test: app.info Lines: 8 41 19.5 %
Date: 2017-04-26 Functions: 3 24 12.5 %

          Line data    Source code
       1             : // This file is generated
       2             : 
       3             : // Copyright (c) 2016 The Chromium Authors. All rights reserved.
       4             : // Use of this source code is governed by a BSD-style license that can be
       5             : // found in the LICENSE file.
       6             : 
       7             : #ifndef v8_inspector_protocol_HeapProfiler_h
       8             : #define v8_inspector_protocol_HeapProfiler_h
       9             : 
      10             : #include "src/inspector/protocol/Protocol.h"
      11             : // For each imported domain we generate a ValueConversions struct instead of a full domain definition
      12             : // and include Domain::API version from there.
      13             : #include "src/inspector/protocol/Runtime.h"
      14             : 
      15             : namespace v8_inspector {
      16             : namespace protocol {
      17             : namespace HeapProfiler {
      18             : 
      19             : // ------------- Forward and enum declarations.
      20             : // Heap snapshot object id.
      21             : using HeapSnapshotObjectId = String;
      22             : // Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
      23             : class SamplingHeapProfileNode;
      24             : // Profile.
      25             : class SamplingHeapProfile;
      26             : // Wrapper for notification params
      27             : class AddHeapSnapshotChunkNotification;
      28             : // Wrapper for notification params
      29             : using ResetProfilesNotification = Object;
      30             : // Wrapper for notification params
      31             : class ReportHeapSnapshotProgressNotification;
      32             : // Wrapper for notification params
      33             : class LastSeenObjectIdNotification;
      34             : // Wrapper for notification params
      35             : class HeapStatsUpdateNotification;
      36             : 
      37             : // ------------- Type and builder declarations.
      38             : 
      39             : // Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.
      40             : class  SamplingHeapProfileNode : public Serializable{
      41             :     PROTOCOL_DISALLOW_COPY(SamplingHeapProfileNode);
      42             : public:
      43             :     static std::unique_ptr<SamplingHeapProfileNode> fromValue(protocol::Value* value, ErrorSupport* errors);
      44             : 
      45           0 :     ~SamplingHeapProfileNode() override { }
      46             : 
      47             :     protocol::Runtime::CallFrame* getCallFrame() { return m_callFrame.get(); }
      48             :     void setCallFrame(std::unique_ptr<protocol::Runtime::CallFrame> value) { m_callFrame = std::move(value); }
      49             : 
      50             :     double getSelfSize() { return m_selfSize; }
      51           0 :     void setSelfSize(double value) { m_selfSize = value; }
      52             : 
      53             :     protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>* getChildren() { return m_children.get(); }
      54             :     void setChildren(std::unique_ptr<protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>> value) { m_children = std::move(value); }
      55             : 
      56             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
      57           0 :     String serialize() override { return toValue()->serialize(); }
      58             :     std::unique_ptr<SamplingHeapProfileNode> clone() const;
      59             : 
      60             :     template<int STATE>
      61             :     class SamplingHeapProfileNodeBuilder {
      62             :     public:
      63             :         enum {
      64             :             NoFieldsSet = 0,
      65             :           CallFrameSet = 1 << 1,
      66             :           SelfSizeSet = 1 << 2,
      67             :           ChildrenSet = 1 << 3,
      68             :             AllFieldsSet = (CallFrameSet | SelfSizeSet | ChildrenSet | 0)};
      69             : 
      70             : 
      71             :         SamplingHeapProfileNodeBuilder<STATE | CallFrameSet>& setCallFrame(std::unique_ptr<protocol::Runtime::CallFrame> value)
      72             :         {
      73             :             static_assert(!(STATE & CallFrameSet), "property callFrame should not be set yet");
      74             :             m_result->setCallFrame(std::move(value));
      75             :             return castState<CallFrameSet>();
      76             :         }
      77             : 
      78             :         SamplingHeapProfileNodeBuilder<STATE | SelfSizeSet>& setSelfSize(double value)
      79             :         {
      80             :             static_assert(!(STATE & SelfSizeSet), "property selfSize should not be set yet");
      81             :             m_result->setSelfSize(value);
      82             :             return castState<SelfSizeSet>();
      83             :         }
      84             : 
      85             :         SamplingHeapProfileNodeBuilder<STATE | ChildrenSet>& setChildren(std::unique_ptr<protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>> value)
      86             :         {
      87             :             static_assert(!(STATE & ChildrenSet), "property children should not be set yet");
      88             :             m_result->setChildren(std::move(value));
      89             :             return castState<ChildrenSet>();
      90             :         }
      91             : 
      92             :         std::unique_ptr<SamplingHeapProfileNode> build()
      93             :         {
      94             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
      95             :             return std::move(m_result);
      96             :         }
      97             : 
      98             :     private:
      99             :         friend class SamplingHeapProfileNode;
     100           0 :         SamplingHeapProfileNodeBuilder() : m_result(new SamplingHeapProfileNode()) { }
     101             : 
     102             :         template<int STEP> SamplingHeapProfileNodeBuilder<STATE | STEP>& castState()
     103             :         {
     104             :             return *reinterpret_cast<SamplingHeapProfileNodeBuilder<STATE | STEP>*>(this);
     105             :         }
     106             : 
     107             :         std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> m_result;
     108             :     };
     109             : 
     110             :     static SamplingHeapProfileNodeBuilder<0> create()
     111             :     {
     112           0 :         return SamplingHeapProfileNodeBuilder<0>();
     113             :     }
     114             : 
     115             : private:
     116             :     SamplingHeapProfileNode()
     117           0 :     {
     118           0 :           m_selfSize = 0;
     119             :     }
     120             : 
     121             :     std::unique_ptr<protocol::Runtime::CallFrame> m_callFrame;
     122             :     double m_selfSize;
     123             :     std::unique_ptr<protocol::Array<protocol::HeapProfiler::SamplingHeapProfileNode>> m_children;
     124             : };
     125             : 
     126             : 
     127             : // Profile.
     128             : class  SamplingHeapProfile : public Serializable{
     129             :     PROTOCOL_DISALLOW_COPY(SamplingHeapProfile);
     130             : public:
     131             :     static std::unique_ptr<SamplingHeapProfile> fromValue(protocol::Value* value, ErrorSupport* errors);
     132             : 
     133           0 :     ~SamplingHeapProfile() override { }
     134             : 
     135             :     protocol::HeapProfiler::SamplingHeapProfileNode* getHead() { return m_head.get(); }
     136             :     void setHead(std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> value) { m_head = std::move(value); }
     137             : 
     138             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     139           0 :     String serialize() override { return toValue()->serialize(); }
     140             :     std::unique_ptr<SamplingHeapProfile> clone() const;
     141             : 
     142             :     template<int STATE>
     143             :     class SamplingHeapProfileBuilder {
     144             :     public:
     145             :         enum {
     146             :             NoFieldsSet = 0,
     147             :           HeadSet = 1 << 1,
     148             :             AllFieldsSet = (HeadSet | 0)};
     149             : 
     150             : 
     151             :         SamplingHeapProfileBuilder<STATE | HeadSet>& setHead(std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> value)
     152             :         {
     153             :             static_assert(!(STATE & HeadSet), "property head should not be set yet");
     154             :             m_result->setHead(std::move(value));
     155             :             return castState<HeadSet>();
     156             :         }
     157             : 
     158             :         std::unique_ptr<SamplingHeapProfile> build()
     159             :         {
     160             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
     161             :             return std::move(m_result);
     162             :         }
     163             : 
     164             :     private:
     165             :         friend class SamplingHeapProfile;
     166           0 :         SamplingHeapProfileBuilder() : m_result(new SamplingHeapProfile()) { }
     167             : 
     168             :         template<int STEP> SamplingHeapProfileBuilder<STATE | STEP>& castState()
     169             :         {
     170             :             return *reinterpret_cast<SamplingHeapProfileBuilder<STATE | STEP>*>(this);
     171             :         }
     172             : 
     173             :         std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile> m_result;
     174             :     };
     175             : 
     176             :     static SamplingHeapProfileBuilder<0> create()
     177             :     {
     178             :         return SamplingHeapProfileBuilder<0>();
     179             :     }
     180             : 
     181             : private:
     182             :     SamplingHeapProfile()
     183           0 :     {
     184             :     }
     185             : 
     186             :     std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfileNode> m_head;
     187             : };
     188             : 
     189             : 
     190             : // Wrapper for notification params
     191             : class  AddHeapSnapshotChunkNotification : public Serializable{
     192             :     PROTOCOL_DISALLOW_COPY(AddHeapSnapshotChunkNotification);
     193             : public:
     194             :     static std::unique_ptr<AddHeapSnapshotChunkNotification> fromValue(protocol::Value* value, ErrorSupport* errors);
     195             : 
     196         352 :     ~AddHeapSnapshotChunkNotification() override { }
     197             : 
     198             :     String getChunk() { return m_chunk; }
     199             :     void setChunk(const String& value) { m_chunk = value; }
     200             : 
     201             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     202         528 :     String serialize() override { return toValue()->serialize(); }
     203             :     std::unique_ptr<AddHeapSnapshotChunkNotification> clone() const;
     204             : 
     205             :     template<int STATE>
     206             :     class AddHeapSnapshotChunkNotificationBuilder {
     207             :     public:
     208             :         enum {
     209             :             NoFieldsSet = 0,
     210             :           ChunkSet = 1 << 1,
     211             :             AllFieldsSet = (ChunkSet | 0)};
     212             : 
     213             : 
     214             :         AddHeapSnapshotChunkNotificationBuilder<STATE | ChunkSet>& setChunk(const String& value)
     215             :         {
     216             :             static_assert(!(STATE & ChunkSet), "property chunk should not be set yet");
     217             :             m_result->setChunk(value);
     218             :             return castState<ChunkSet>();
     219             :         }
     220             : 
     221             :         std::unique_ptr<AddHeapSnapshotChunkNotification> build()
     222             :         {
     223             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
     224             :             return std::move(m_result);
     225             :         }
     226             : 
     227             :     private:
     228             :         friend class AddHeapSnapshotChunkNotification;
     229         352 :         AddHeapSnapshotChunkNotificationBuilder() : m_result(new AddHeapSnapshotChunkNotification()) { }
     230             : 
     231             :         template<int STEP> AddHeapSnapshotChunkNotificationBuilder<STATE | STEP>& castState()
     232             :         {
     233             :             return *reinterpret_cast<AddHeapSnapshotChunkNotificationBuilder<STATE | STEP>*>(this);
     234             :         }
     235             : 
     236             :         std::unique_ptr<protocol::HeapProfiler::AddHeapSnapshotChunkNotification> m_result;
     237             :     };
     238             : 
     239             :     static AddHeapSnapshotChunkNotificationBuilder<0> create()
     240             :     {
     241         176 :         return AddHeapSnapshotChunkNotificationBuilder<0>();
     242             :     }
     243             : 
     244             : private:
     245             :     AddHeapSnapshotChunkNotification()
     246         176 :     {
     247             :     }
     248             : 
     249             :     String m_chunk;
     250             : };
     251             : 
     252             : 
     253             : // Wrapper for notification params
     254             : class  ReportHeapSnapshotProgressNotification : public Serializable{
     255             :     PROTOCOL_DISALLOW_COPY(ReportHeapSnapshotProgressNotification);
     256             : public:
     257             :     static std::unique_ptr<ReportHeapSnapshotProgressNotification> fromValue(protocol::Value* value, ErrorSupport* errors);
     258             : 
     259           0 :     ~ReportHeapSnapshotProgressNotification() override { }
     260             : 
     261             :     int getDone() { return m_done; }
     262           0 :     void setDone(int value) { m_done = value; }
     263             : 
     264             :     int getTotal() { return m_total; }
     265           0 :     void setTotal(int value) { m_total = value; }
     266             : 
     267             :     bool hasFinished() { return m_finished.isJust(); }
     268             :     bool getFinished(bool defaultValue) { return m_finished.isJust() ? m_finished.fromJust() : defaultValue; }
     269             :     void setFinished(bool value) { m_finished = value; }
     270             : 
     271             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     272           0 :     String serialize() override { return toValue()->serialize(); }
     273             :     std::unique_ptr<ReportHeapSnapshotProgressNotification> clone() const;
     274             : 
     275             :     template<int STATE>
     276             :     class ReportHeapSnapshotProgressNotificationBuilder {
     277             :     public:
     278             :         enum {
     279             :             NoFieldsSet = 0,
     280             :           DoneSet = 1 << 1,
     281             :           TotalSet = 1 << 2,
     282             :             AllFieldsSet = (DoneSet | TotalSet | 0)};
     283             : 
     284             : 
     285             :         ReportHeapSnapshotProgressNotificationBuilder<STATE | DoneSet>& setDone(int value)
     286             :         {
     287             :             static_assert(!(STATE & DoneSet), "property done should not be set yet");
     288             :             m_result->setDone(value);
     289             :             return castState<DoneSet>();
     290             :         }
     291             : 
     292             :         ReportHeapSnapshotProgressNotificationBuilder<STATE | TotalSet>& setTotal(int value)
     293             :         {
     294             :             static_assert(!(STATE & TotalSet), "property total should not be set yet");
     295             :             m_result->setTotal(value);
     296             :             return castState<TotalSet>();
     297             :         }
     298             : 
     299             :         ReportHeapSnapshotProgressNotificationBuilder<STATE>& setFinished(bool value)
     300             :         {
     301             :             m_result->setFinished(value);
     302             :             return *this;
     303             :         }
     304             : 
     305             :         std::unique_ptr<ReportHeapSnapshotProgressNotification> build()
     306             :         {
     307             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
     308             :             return std::move(m_result);
     309             :         }
     310             : 
     311             :     private:
     312             :         friend class ReportHeapSnapshotProgressNotification;
     313           0 :         ReportHeapSnapshotProgressNotificationBuilder() : m_result(new ReportHeapSnapshotProgressNotification()) { }
     314             : 
     315             :         template<int STEP> ReportHeapSnapshotProgressNotificationBuilder<STATE | STEP>& castState()
     316             :         {
     317             :             return *reinterpret_cast<ReportHeapSnapshotProgressNotificationBuilder<STATE | STEP>*>(this);
     318             :         }
     319             : 
     320             :         std::unique_ptr<protocol::HeapProfiler::ReportHeapSnapshotProgressNotification> m_result;
     321             :     };
     322             : 
     323             :     static ReportHeapSnapshotProgressNotificationBuilder<0> create()
     324             :     {
     325           0 :         return ReportHeapSnapshotProgressNotificationBuilder<0>();
     326             :     }
     327             : 
     328             : private:
     329             :     ReportHeapSnapshotProgressNotification()
     330           0 :     {
     331           0 :           m_done = 0;
     332           0 :           m_total = 0;
     333             :     }
     334             : 
     335             :     int m_done;
     336             :     int m_total;
     337             :     Maybe<bool> m_finished;
     338             : };
     339             : 
     340             : 
     341             : // Wrapper for notification params
     342             : class  LastSeenObjectIdNotification : public Serializable{
     343             :     PROTOCOL_DISALLOW_COPY(LastSeenObjectIdNotification);
     344             : public:
     345             :     static std::unique_ptr<LastSeenObjectIdNotification> fromValue(protocol::Value* value, ErrorSupport* errors);
     346             : 
     347           0 :     ~LastSeenObjectIdNotification() override { }
     348             : 
     349             :     int getLastSeenObjectId() { return m_lastSeenObjectId; }
     350           0 :     void setLastSeenObjectId(int value) { m_lastSeenObjectId = value; }
     351             : 
     352             :     double getTimestamp() { return m_timestamp; }
     353           0 :     void setTimestamp(double value) { m_timestamp = value; }
     354             : 
     355             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     356           0 :     String serialize() override { return toValue()->serialize(); }
     357             :     std::unique_ptr<LastSeenObjectIdNotification> clone() const;
     358             : 
     359             :     template<int STATE>
     360             :     class LastSeenObjectIdNotificationBuilder {
     361             :     public:
     362             :         enum {
     363             :             NoFieldsSet = 0,
     364             :           LastSeenObjectIdSet = 1 << 1,
     365             :           TimestampSet = 1 << 2,
     366             :             AllFieldsSet = (LastSeenObjectIdSet | TimestampSet | 0)};
     367             : 
     368             : 
     369             :         LastSeenObjectIdNotificationBuilder<STATE | LastSeenObjectIdSet>& setLastSeenObjectId(int value)
     370             :         {
     371             :             static_assert(!(STATE & LastSeenObjectIdSet), "property lastSeenObjectId should not be set yet");
     372             :             m_result->setLastSeenObjectId(value);
     373             :             return castState<LastSeenObjectIdSet>();
     374             :         }
     375             : 
     376             :         LastSeenObjectIdNotificationBuilder<STATE | TimestampSet>& setTimestamp(double value)
     377             :         {
     378             :             static_assert(!(STATE & TimestampSet), "property timestamp should not be set yet");
     379             :             m_result->setTimestamp(value);
     380             :             return castState<TimestampSet>();
     381             :         }
     382             : 
     383             :         std::unique_ptr<LastSeenObjectIdNotification> build()
     384             :         {
     385             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
     386             :             return std::move(m_result);
     387             :         }
     388             : 
     389             :     private:
     390             :         friend class LastSeenObjectIdNotification;
     391           0 :         LastSeenObjectIdNotificationBuilder() : m_result(new LastSeenObjectIdNotification()) { }
     392             : 
     393             :         template<int STEP> LastSeenObjectIdNotificationBuilder<STATE | STEP>& castState()
     394             :         {
     395             :             return *reinterpret_cast<LastSeenObjectIdNotificationBuilder<STATE | STEP>*>(this);
     396             :         }
     397             : 
     398             :         std::unique_ptr<protocol::HeapProfiler::LastSeenObjectIdNotification> m_result;
     399             :     };
     400             : 
     401             :     static LastSeenObjectIdNotificationBuilder<0> create()
     402             :     {
     403           0 :         return LastSeenObjectIdNotificationBuilder<0>();
     404             :     }
     405             : 
     406             : private:
     407             :     LastSeenObjectIdNotification()
     408           0 :     {
     409           0 :           m_lastSeenObjectId = 0;
     410           0 :           m_timestamp = 0;
     411             :     }
     412             : 
     413             :     int m_lastSeenObjectId;
     414             :     double m_timestamp;
     415             : };
     416             : 
     417             : 
     418             : // Wrapper for notification params
     419             : class  HeapStatsUpdateNotification : public Serializable{
     420             :     PROTOCOL_DISALLOW_COPY(HeapStatsUpdateNotification);
     421             : public:
     422             :     static std::unique_ptr<HeapStatsUpdateNotification> fromValue(protocol::Value* value, ErrorSupport* errors);
     423             : 
     424           0 :     ~HeapStatsUpdateNotification() override { }
     425             : 
     426             :     protocol::Array<int>* getStatsUpdate() { return m_statsUpdate.get(); }
     427             :     void setStatsUpdate(std::unique_ptr<protocol::Array<int>> value) { m_statsUpdate = std::move(value); }
     428             : 
     429             :     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     430           0 :     String serialize() override { return toValue()->serialize(); }
     431             :     std::unique_ptr<HeapStatsUpdateNotification> clone() const;
     432             : 
     433             :     template<int STATE>
     434             :     class HeapStatsUpdateNotificationBuilder {
     435             :     public:
     436             :         enum {
     437             :             NoFieldsSet = 0,
     438             :           StatsUpdateSet = 1 << 1,
     439             :             AllFieldsSet = (StatsUpdateSet | 0)};
     440             : 
     441             : 
     442             :         HeapStatsUpdateNotificationBuilder<STATE | StatsUpdateSet>& setStatsUpdate(std::unique_ptr<protocol::Array<int>> value)
     443             :         {
     444             :             static_assert(!(STATE & StatsUpdateSet), "property statsUpdate should not be set yet");
     445             :             m_result->setStatsUpdate(std::move(value));
     446             :             return castState<StatsUpdateSet>();
     447             :         }
     448             : 
     449             :         std::unique_ptr<HeapStatsUpdateNotification> build()
     450             :         {
     451             :             static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
     452             :             return std::move(m_result);
     453             :         }
     454             : 
     455             :     private:
     456             :         friend class HeapStatsUpdateNotification;
     457           0 :         HeapStatsUpdateNotificationBuilder() : m_result(new HeapStatsUpdateNotification()) { }
     458             : 
     459             :         template<int STEP> HeapStatsUpdateNotificationBuilder<STATE | STEP>& castState()
     460             :         {
     461             :             return *reinterpret_cast<HeapStatsUpdateNotificationBuilder<STATE | STEP>*>(this);
     462             :         }
     463             : 
     464             :         std::unique_ptr<protocol::HeapProfiler::HeapStatsUpdateNotification> m_result;
     465             :     };
     466             : 
     467             :     static HeapStatsUpdateNotificationBuilder<0> create()
     468             :     {
     469             :         return HeapStatsUpdateNotificationBuilder<0>();
     470             :     }
     471             : 
     472             : private:
     473             :     HeapStatsUpdateNotification()
     474           0 :     {
     475             :     }
     476             : 
     477             :     std::unique_ptr<protocol::Array<int>> m_statsUpdate;
     478             : };
     479             : 
     480             : 
     481             : // ------------- Backend interface.
     482             : 
     483        4573 : class  Backend {
     484             : public:
     485        4573 :     virtual ~Backend() { }
     486             : 
     487             :     virtual DispatchResponse enable() = 0;
     488             :     virtual DispatchResponse disable() = 0;
     489             :     virtual DispatchResponse startTrackingHeapObjects(Maybe<bool> in_trackAllocations) = 0;
     490             :     virtual DispatchResponse stopTrackingHeapObjects(Maybe<bool> in_reportProgress) = 0;
     491             :     virtual DispatchResponse takeHeapSnapshot(Maybe<bool> in_reportProgress) = 0;
     492             :     virtual DispatchResponse collectGarbage() = 0;
     493             :     virtual DispatchResponse getObjectByHeapObjectId(const String& in_objectId, Maybe<String> in_objectGroup, std::unique_ptr<protocol::Runtime::RemoteObject>* out_result) = 0;
     494             :     virtual DispatchResponse addInspectedHeapObject(const String& in_heapObjectId) = 0;
     495             :     virtual DispatchResponse getHeapObjectId(const String& in_objectId, String* out_heapSnapshotObjectId) = 0;
     496             :     virtual DispatchResponse startSampling(Maybe<double> in_samplingInterval) = 0;
     497             :     virtual DispatchResponse stopSampling(std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>* out_profile) = 0;
     498             : 
     499             : };
     500             : 
     501             : // ------------- Frontend interface.
     502             : 
     503             : class  Frontend {
     504             : public:
     505        4573 :     explicit Frontend(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
     506             :     void addHeapSnapshotChunk(const String& chunk);
     507             :     void resetProfiles();
     508             :     void reportHeapSnapshotProgress(int done, int total, Maybe<bool> finished = Maybe<bool>());
     509             :     void lastSeenObjectId(int lastSeenObjectId, double timestamp);
     510             :     void heapStatsUpdate(std::unique_ptr<protocol::Array<int>> statsUpdate);
     511             : 
     512             :     void flush();
     513             :     void sendRawNotification(const String&);
     514             : private:
     515             :     FrontendChannel* m_frontendChannel;
     516             : };
     517             : 
     518             : // ------------- Dispatcher.
     519             : 
     520             : class  Dispatcher {
     521             : public:
     522             :     static void wire(UberDispatcher*, Backend*);
     523             : 
     524             : private:
     525             :     Dispatcher() { }
     526             : };
     527             : 
     528             : // ------------- Metainfo.
     529             : 
     530             : class  Metainfo {
     531             : public:
     532             :     using BackendClass = Backend;
     533             :     using FrontendClass = Frontend;
     534             :     using DispatcherClass = Dispatcher;
     535             :     static const char domainName[];
     536             :     static const char commandPrefix[];
     537             :     static const char version[];
     538             : };
     539             : 
     540             : } // namespace HeapProfiler
     541             : } // namespace v8_inspector
     542             : } // namespace protocol
     543             : 
     544             : #endif // !defined(v8_inspector_protocol_HeapProfiler_h)

Generated by: LCOV version 1.10