react-native 0.0.0-e6fc20ee6 → 0.0.0-e9440508e-20211011-2008

package/ReactCommon/hermes/inspector/chrome/Connection.cpp

@@ -9,6 +9,7 @@
 
 #include <cstdlib>
 #include <mutex>
+#include <sstream>
 
 #include <folly/Conv.h>
 #include <folly/Executor.h>
@@ -81,6 +82,7 @@ class Connection::Impl : public inspector::InspectorObserver,
   void handle(const m::debugger::ResumeRequest &req) override;
   void handle(const m::debugger::SetBreakpointRequest &req) override;
   void handle(const m::debugger::SetBreakpointByUrlRequest &req) override;
+  void handle(const m::debugger::SetBreakpointsActiveRequest &req) override;
   void handle(
       const m::debugger::SetInstrumentationBreakpointRequest &req) override;
   void handle(const m::debugger::SetPauseOnExceptionsRequest &req) override;
@@ -92,6 +94,12 @@ class Connection::Impl : public inspector::InspectorObserver,
       const m::heapProfiler::StartTrackingHeapObjectsRequest &req) override;
   void handle(
       const m::heapProfiler::StopTrackingHeapObjectsRequest &req) override;
+  void handle(const m::heapProfiler::StartSamplingRequest &req) override;
+  void handle(const m::heapProfiler::StopSamplingRequest &req) override;
+  void handle(const m::heapProfiler::CollectGarbageRequest &req) override;
+  void handle(
+      const m::heapProfiler::GetObjectByHeapObjectIdRequest &req) override;
+  void handle(const m::heapProfiler::GetHeapObjectIdRequest &req) override;
   void handle(const m::runtime::EvaluateRequest &req) override;
   void handle(const m::runtime::GetPropertiesRequest &req) override;
   void handle(const m::runtime::RunIfWaitingForDebuggerRequest &req) override;
@@ -216,8 +224,8 @@ bool Connection::Impl::disconnect() {
 
   inspector_->disable().via(executor_.get()).thenValue([this](auto &&) {
     // HACK:  We purposely call RemoteConnection::onDisconnect on a *different*
-    // rather than on this thread (the executor thread). This is to prevent this
-    // scenario:
+    // thread, rather than on this thread (the executor thread). This is to
+    // prevent this scenario:
     //
     // 1. RemoteConnection::onDisconnect runs on the executor thread
     // 2. onDisconnect through a long chain of calls causes the Connection
@@ -468,6 +476,13 @@ void Connection::Impl::sendSnapshot(
           message,
           [this, reportProgress, stopStackTraceCapture](
               const debugger::ProgramState &) {
+            // Stop taking any new traces before sending out the heap snapshot.
+            if (stopStackTraceCapture) {
+              getRuntime()
+                  .instrumentation()
+                  .stopTrackingHeapObjectStackTraces();
+            }
+
             if (reportProgress) {
               // A progress notification with finished = true indicates the
               // snapshot has been captured and is ready to be sent.  Our
@@ -491,11 +506,6 @@ void Connection::Impl::sendSnapshot(
                 });
 
             getRuntime().instrumentation().createSnapshotToStream(cos);
-            if (stopStackTraceCapture) {
-              getRuntime()
-                  .instrumentation()
-                  .stopTrackingHeapObjectStackTraces();
-            }
           })
       .via(executor_.get())
       .thenValue([this, reqId](auto &&) {
@@ -521,7 +531,45 @@ void Connection::Impl::handle(
       ->executeIfEnabled(
           "HeapProfiler.startTrackingHeapObjects",
           [this](const debugger::ProgramState &) {
-            getRuntime().instrumentation().startTrackingHeapObjectStackTraces();
+            getRuntime().instrumentation().startTrackingHeapObjectStackTraces(
+                [this](
+                    uint64_t lastSeenObjectId,
+                    std::chrono::microseconds timestamp,
+                    std::vector<jsi::Instrumentation::HeapStatsUpdate> stats) {
+                  // Send the last object ID notification first.
+                  m::heapProfiler::LastSeenObjectIdNotification note;
+                  note.lastSeenObjectId = lastSeenObjectId;
+                  // The protocol uses milliseconds with a fraction for
+                  // microseconds.
+                  note.timestamp =
+                      static_cast<double>(timestamp.count()) / 1000;
+                  sendNotificationToClient(note);
+
+                  m::heapProfiler::HeapStatsUpdateNotification heapStatsNote;
+                  // Flatten the HeapStatsUpdate list.
+                  heapStatsNote.statsUpdate.reserve(stats.size() * 3);
+                  for (const jsi::Instrumentation::HeapStatsUpdate &fragment :
+                       stats) {
+                    // Each triplet is the fragment number, the total count of
+                    // objects for the fragment, and the total size of objects
+                    // for the fragment.
+                    heapStatsNote.statsUpdate.push_back(
+                        static_cast<int>(std::get<0>(fragment)));
+                    heapStatsNote.statsUpdate.push_back(
+                        static_cast<int>(std::get<1>(fragment)));
+                    heapStatsNote.statsUpdate.push_back(
+                        static_cast<int>(std::get<2>(fragment)));
+                  }
+                  assert(
+                      heapStatsNote.statsUpdate.size() == stats.size() * 3 &&
+                      "Should be exactly 3x the stats vector");
+                  // TODO: Chunk this if there are too many fragments to update.
+                  // Unlikely to be a problem in practice unless there's a huge
+                  // amount of allocation and freeing.
+                  sendNotificationToClient(heapStatsNote);
+                });
+            // At this point we need the equivalent of a setInterval, where each
+            // interval samples the existing
           })
       .via(executor_.get())
       .thenValue(
@@ -538,6 +586,131 @@ void Connection::Impl::handle(
       /* stopStackTraceCapture */ true);
 }
 
+void Connection::Impl::handle(
+    const m::heapProfiler::StartSamplingRequest &req) {
+  const auto id = req.id;
+  // This is the same default sampling interval that Chrome uses.
+  // https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#method-startSampling
+  constexpr size_t kDefaultSamplingInterval = 1 << 15;
+  const size_t samplingInterval =
+      req.samplingInterval.value_or(kDefaultSamplingInterval);
+
+  inspector_
+      ->executeIfEnabled(
+          "HeapProfiler.startSampling",
+          [this, samplingInterval](const debugger::ProgramState &) {
+            getRuntime().instrumentation().startHeapSampling(samplingInterval);
+          })
+      .via(executor_.get())
+      .thenValue(
+          [this, id](auto &&) { sendResponseToClient(m::makeOkResponse(id)); })
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
+void Connection::Impl::handle(const m::heapProfiler::StopSamplingRequest &req) {
+  inspector_
+      ->executeIfEnabled(
+          "HeapProfiler.stopSampling",
+          [this, id = req.id](const debugger::ProgramState &) {
+            std::ostringstream stream;
+            getRuntime().instrumentation().stopHeapSampling(stream);
+            folly::dynamic json = folly::parseJson(stream.str());
+            m::heapProfiler::StopSamplingResponse resp;
+            resp.id = id;
+            m::heapProfiler::SamplingHeapProfile profile{json};
+            resp.profile = profile;
+            sendResponseToClient(resp);
+          })
+      .via(executor_.get())
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
+void Connection::Impl::handle(
+    const m::heapProfiler::CollectGarbageRequest &req) {
+  const auto id = req.id;
+
+  inspector_
+      ->executeIfEnabled(
+          "HeapProfiler.collectGarbage",
+          [this](const debugger::ProgramState &) {
+            getRuntime().instrumentation().collectGarbage("inspector");
+          })
+      .via(executor_.get())
+      .thenValue(
+          [this, id](auto &&) { sendResponseToClient(m::makeOkResponse(id)); })
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
+void Connection::Impl::handle(
+    const m::heapProfiler::GetObjectByHeapObjectIdRequest &req) {
+  uint64_t objID = atoi(req.objectId.c_str());
+  folly::Optional<std::string> group = req.objectGroup;
+  auto remoteObjPtr = std::make_shared<m::runtime::RemoteObject>();
+
+  inspector_
+      ->executeIfEnabled(
+          "HeapProfiler.getObjectByHeapObjectId",
+          [this, remoteObjPtr, objID, group](const debugger::ProgramState &) {
+            jsi::Runtime *rt = &getRuntime();
+            if (auto *hermesRT = dynamic_cast<HermesRuntime *>(rt)) {
+              jsi::Value val = hermesRT->getObjectForID(objID);
+              if (val.isNull()) {
+                return;
+              }
+              *remoteObjPtr = m::runtime::makeRemoteObject(
+                  getRuntime(), val, objTable_, group.value_or(""));
+            }
+          })
+      .via(executor_.get())
+      .thenValue([this, id = req.id, remoteObjPtr](auto &&) {
+        if (!remoteObjPtr->type.empty()) {
+          m::heapProfiler::GetObjectByHeapObjectIdResponse resp;
+          resp.id = id;
+          resp.result = *remoteObjPtr;
+          sendResponseToClient(resp);
+        } else {
+          sendResponseToClient(m::makeErrorResponse(
+              id, m::ErrorCode::ServerError, "Object is not available"));
+        }
+      })
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
+void Connection::Impl::handle(
+    const m::heapProfiler::GetHeapObjectIdRequest &req) {
+  // Use a shared_ptr because the stack frame will go away.
+  std::shared_ptr<uint64_t> snapshotID = std::make_shared<uint64_t>(0);
+
+  inspector_
+      ->executeIfEnabled(
+          "HeapProfiler.getHeapObjectId",
+          [this, req, snapshotID](const debugger::ProgramState &) {
+            if (const jsi::Value *valuePtr = objTable_.getValue(req.objectId)) {
+              jsi::Runtime *rt = &getRuntime();
+              if (auto *hermesRT = dynamic_cast<HermesRuntime *>(rt)) {
+                *snapshotID = hermesRT->getUniqueID(*valuePtr);
+              }
+            }
+          })
+      .via(executor_.get())
+      .thenValue([this, id = req.id, snapshotID](auto &&) {
+        if (*snapshotID) {
+          m::heapProfiler::GetHeapObjectIdResponse resp;
+          resp.id = id;
+          // std::to_string is not available on Android, use a std::ostream
+          // instead.
+          std::ostringstream stream;
+          stream << *snapshotID;
+          resp.heapSnapshotObjectId = stream.str();
+          sendResponseToClient(resp);
+        } else {
+          sendResponseToClient(m::makeErrorResponse(
+              id, m::ErrorCode::ServerError, "Object is not available"));
+        }
+      })
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
 void Connection::Impl::handle(const m::runtime::EvaluateRequest &req) {
   auto remoteObjPtr = std::make_shared<m::runtime::RemoteObject>();
 
@@ -659,6 +832,16 @@ void Connection::Impl::handle(
       .thenError<std::exception>(sendErrorToClient(req.id));
 }
 
+void Connection::Impl::handle(
+    const m::debugger::SetBreakpointsActiveRequest &req) {
+  inspector_->setBreakpointsActive(req.active)
+      .via(executor_.get())
+      .thenValue([this, id = req.id](const Unit &unit) {
+        sendResponseToClient(m::makeOkResponse(id));
+      })
+      .thenError<std::exception>(sendErrorToClient(req.id));
+}
+
 bool Connection::Impl::isVirtualBreakpointId(const std::string &id) {
   return id.rfind(kVirtualBreakpointPrefix, 0) == 0;
 }

package/ReactCommon/hermes/inspector/chrome/Connection.h

@@ -5,7 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#pragma once
+// using include guards instead of #pragma once due to compile issues
+// with MSVC and BUCK
+#ifndef HERMES_INSPECTOR_CONNECTION_H
+#define HERMES_INSPECTOR_CONNECTION_H
 
 #include <functional>
 #include <memory>
@@ -21,7 +24,7 @@ namespace inspector {
 namespace chrome {
 
 /// Connection is a duplex connection between the client and the debugger.
-class Connection {
+class INSPECTOR_EXPORT Connection {
  public:
   /// Connection constructor enables the debugger on the provided runtime. This
   /// should generally called before you start running any JS in the runtime.
@@ -60,3 +63,5 @@ class Connection {
 } // namespace inspector
 } // namespace hermes
 } // namespace facebook
+
+#endif // HERMES_INSPECTOR_CONNECTION_H

package/ReactCommon/hermes/inspector/chrome/MessageTypes.cpp

@@ -1,5 +1,5 @@
 // Copyright 2004-present Facebook. All Rights Reserved.
-// @generated SignedSource<<f251363b69dd291d2c70e893c3fed04d>>
+// @generated SignedSource<<522f29c54f207a4f7b5c33af07cf64d0>>
 
 #include "MessageTypes.h"
 
@@ -35,6 +35,8 @@ std::unique_ptr<Request> Request::fromJsonThrowOnError(const std::string &str) {
       {"Debugger.setBreakpoint", makeUnique<debugger::SetBreakpointRequest>},
       {"Debugger.setBreakpointByUrl",
        makeUnique<debugger::SetBreakpointByUrlRequest>},
+      {"Debugger.setBreakpointsActive",
+       makeUnique<debugger::SetBreakpointsActiveRequest>},
       {"Debugger.setInstrumentationBreakpoint",
        makeUnique<debugger::SetInstrumentationBreakpointRequest>},
       {"Debugger.setPauseOnExceptions",
@@ -42,8 +44,18 @@ std::unique_ptr<Request> Request::fromJsonThrowOnError(const std::string &str) {
       {"Debugger.stepInto", makeUnique<debugger::StepIntoRequest>},
       {"Debugger.stepOut", makeUnique<debugger::StepOutRequest>},
       {"Debugger.stepOver", makeUnique<debugger::StepOverRequest>},
+      {"HeapProfiler.collectGarbage",
+       makeUnique<heapProfiler::CollectGarbageRequest>},
+      {"HeapProfiler.getHeapObjectId",
+       makeUnique<heapProfiler::GetHeapObjectIdRequest>},
+      {"HeapProfiler.getObjectByHeapObjectId",
+       makeUnique<heapProfiler::GetObjectByHeapObjectIdRequest>},
+      {"HeapProfiler.startSampling",
+       makeUnique<heapProfiler::StartSamplingRequest>},
       {"HeapProfiler.startTrackingHeapObjects",
        makeUnique<heapProfiler::StartTrackingHeapObjectsRequest>},
+      {"HeapProfiler.stopSampling",
+       makeUnique<heapProfiler::StopSamplingRequest>},
       {"HeapProfiler.stopTrackingHeapObjects",
        makeUnique<heapProfiler::StopTrackingHeapObjectsRequest>},
       {"HeapProfiler.takeHeapSnapshot",
@@ -215,6 +227,53 @@ dynamic debugger::CallFrame::toDynamic() const {
   return obj;
 }
 
+heapProfiler::SamplingHeapProfileNode::SamplingHeapProfileNode(
+    const dynamic &obj) {
+  assign(callFrame, obj, "callFrame");
+  assign(selfSize, obj, "selfSize");
+  assign(id, obj, "id");
+  assign(children, obj, "children");
+}
+
+dynamic heapProfiler::SamplingHeapProfileNode::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "callFrame", callFrame);
+  put(obj, "selfSize", selfSize);
+  put(obj, "id", id);
+  put(obj, "children", children);
+  return obj;
+}
+
+heapProfiler::SamplingHeapProfileSample::SamplingHeapProfileSample(
+    const dynamic &obj) {
+  assign(size, obj, "size");
+  assign(nodeId, obj, "nodeId");
+  assign(ordinal, obj, "ordinal");
+}
+
+dynamic heapProfiler::SamplingHeapProfileSample::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "size", size);
+  put(obj, "nodeId", nodeId);
+  put(obj, "ordinal", ordinal);
+  return obj;
+}
+
+heapProfiler::SamplingHeapProfile::SamplingHeapProfile(const dynamic &obj) {
+  assign(head, obj, "head");
+  assign(samples, obj, "samples");
+}
+
+dynamic heapProfiler::SamplingHeapProfile::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "head", head);
+  put(obj, "samples", samples);
+  return obj;
+}
+
 runtime::ExecutionContextDescription::ExecutionContextDescription(
     const dynamic &obj) {
   assign(id, obj, "id");
@@ -509,6 +568,35 @@ void debugger::SetBreakpointByUrlRequest::accept(
   handler.handle(*this);
 }
 
+debugger::SetBreakpointsActiveRequest::SetBreakpointsActiveRequest()
+    : Request("Debugger.setBreakpointsActive") {}
+
+debugger::SetBreakpointsActiveRequest::SetBreakpointsActiveRequest(
+    const dynamic &obj)
+    : Request("Debugger.setBreakpointsActive") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(active, params, "active");
+}
+
+dynamic debugger::SetBreakpointsActiveRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "active", active);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void debugger::SetBreakpointsActiveRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 debugger::SetInstrumentationBreakpointRequest::
     SetInstrumentationBreakpointRequest()
     : Request("Debugger.setInstrumentationBreakpoint") {}
@@ -625,6 +713,113 @@ void debugger::StepOverRequest::accept(RequestHandler &handler) const {
   handler.handle(*this);
 }
 
+heapProfiler::CollectGarbageRequest::CollectGarbageRequest()
+    : Request("HeapProfiler.collectGarbage") {}
+
+heapProfiler::CollectGarbageRequest::CollectGarbageRequest(const dynamic &obj)
+    : Request("HeapProfiler.collectGarbage") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic heapProfiler::CollectGarbageRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void heapProfiler::CollectGarbageRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+heapProfiler::GetHeapObjectIdRequest::GetHeapObjectIdRequest()
+    : Request("HeapProfiler.getHeapObjectId") {}
+
+heapProfiler::GetHeapObjectIdRequest::GetHeapObjectIdRequest(const dynamic &obj)
+    : Request("HeapProfiler.getHeapObjectId") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(objectId, params, "objectId");
+}
+
+dynamic heapProfiler::GetHeapObjectIdRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "objectId", objectId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::GetHeapObjectIdRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+heapProfiler::GetObjectByHeapObjectIdRequest::GetObjectByHeapObjectIdRequest()
+    : Request("HeapProfiler.getObjectByHeapObjectId") {}
+
+heapProfiler::GetObjectByHeapObjectIdRequest::GetObjectByHeapObjectIdRequest(
+    const dynamic &obj)
+    : Request("HeapProfiler.getObjectByHeapObjectId") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(objectId, params, "objectId");
+  assign(objectGroup, params, "objectGroup");
+}
+
+dynamic heapProfiler::GetObjectByHeapObjectIdRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "objectId", objectId);
+  put(params, "objectGroup", objectGroup);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::GetObjectByHeapObjectIdRequest::accept(
+    RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+heapProfiler::StartSamplingRequest::StartSamplingRequest()
+    : Request("HeapProfiler.startSampling") {}
+
+heapProfiler::StartSamplingRequest::StartSamplingRequest(const dynamic &obj)
+    : Request("HeapProfiler.startSampling") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(samplingInterval, params, "samplingInterval");
+}
+
+dynamic heapProfiler::StartSamplingRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "samplingInterval", samplingInterval);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void heapProfiler::StartSamplingRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 heapProfiler::StartTrackingHeapObjectsRequest::StartTrackingHeapObjectsRequest()
     : Request("HeapProfiler.startTrackingHeapObjects") {}
 
@@ -654,6 +849,26 @@ void heapProfiler::StartTrackingHeapObjectsRequest::accept(
   handler.handle(*this);
 }
 
+heapProfiler::StopSamplingRequest::StopSamplingRequest()
+    : Request("HeapProfiler.stopSampling") {}
+
+heapProfiler::StopSamplingRequest::StopSamplingRequest(const dynamic &obj)
+    : Request("HeapProfiler.stopSampling") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic heapProfiler::StopSamplingRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void heapProfiler::StopSamplingRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 heapProfiler::StopTrackingHeapObjectsRequest::StopTrackingHeapObjectsRequest()
     : Request("HeapProfiler.stopTrackingHeapObjects") {}
 
@@ -919,6 +1134,59 @@ dynamic debugger::SetInstrumentationBreakpointResponse::toDynamic() const {
   return obj;
 }
 
+heapProfiler::GetHeapObjectIdResponse::GetHeapObjectIdResponse(
+    const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(heapSnapshotObjectId, res, "heapSnapshotObjectId");
+}
+
+dynamic heapProfiler::GetHeapObjectIdResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "heapSnapshotObjectId", heapSnapshotObjectId);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
+heapProfiler::GetObjectByHeapObjectIdResponse::GetObjectByHeapObjectIdResponse(
+    const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(result, res, "result");
+}
+
+dynamic heapProfiler::GetObjectByHeapObjectIdResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "result", result);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
+heapProfiler::StopSamplingResponse::StopSamplingResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(profile, res, "profile");
+}
+
+dynamic heapProfiler::StopSamplingResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "profile", profile);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 runtime::EvaluateResponse::EvaluateResponse(const dynamic &obj) {
   assign(id, obj, "id");
 
@@ -1095,6 +1363,52 @@ dynamic heapProfiler::AddHeapSnapshotChunkNotification::toDynamic() const {
   return obj;
 }
 
+heapProfiler::HeapStatsUpdateNotification::HeapStatsUpdateNotification()
+    : Notification("HeapProfiler.heapStatsUpdate") {}
+
+heapProfiler::HeapStatsUpdateNotification::HeapStatsUpdateNotification(
+    const dynamic &obj)
+    : Notification("HeapProfiler.heapStatsUpdate") {
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(statsUpdate, params, "statsUpdate");
+}
+
+dynamic heapProfiler::HeapStatsUpdateNotification::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "statsUpdate", statsUpdate);
+
+  dynamic obj = dynamic::object;
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+heapProfiler::LastSeenObjectIdNotification::LastSeenObjectIdNotification()
+    : Notification("HeapProfiler.lastSeenObjectId") {}
+
+heapProfiler::LastSeenObjectIdNotification::LastSeenObjectIdNotification(
+    const dynamic &obj)
+    : Notification("HeapProfiler.lastSeenObjectId") {
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(lastSeenObjectId, params, "lastSeenObjectId");
+  assign(timestamp, params, "timestamp");
+}
+
+dynamic heapProfiler::LastSeenObjectIdNotification::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "lastSeenObjectId", lastSeenObjectId);
+  put(params, "timestamp", timestamp);
+
+  dynamic obj = dynamic::object;
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
 heapProfiler::ReportHeapSnapshotProgressNotification::
     ReportHeapSnapshotProgressNotification()
     : Notification("HeapProfiler.reportHeapSnapshotProgress") {}