Support captureNumericValue for HeapProfiler domain

Summary:
Original Author: [email protected]
Original Git: 05ee71f
Original Reviewed By: mattbfb
Original Revision: D60871373

Adds support for the `captureNumericValue` flag for
`HeapProfiler.takeHeapSnapshot` and
`HeapProfiler.stopTrackingHeapObjects` of the CDP protocol.

Reviewed By: lavenzg

Differential Revision: D61574205

fbshipit-source-id: c4ebca21e0874d65d61bf03431185c0bf6d810b5

Author: dannysu

API/hermes/cdp/HeapProfilerDomainAgent.cpp

@@ -64,14 +64,20 @@ HeapProfilerDomainAgent::~HeapProfilerDomainAgent() {
 void HeapProfilerDomainAgent::takeHeapSnapshot(
     const m::heapProfiler::TakeHeapSnapshotRequest &req) {
 #ifdef HERMES_MEMORY_INSTRUMENTATION
-  sendSnapshot(req.id, req.reportProgress && *req.reportProgress);
+  sendSnapshot(
+      req.id,
+      req.reportProgress && *req.reportProgress,
+      req.captureNumericValue && *req.captureNumericValue);
 #else
   sendResponseToClient(m::makeErrorResponse(
       req.id, m::ErrorCode::InvalidRequest, kNoInstrumentation));
 #endif // HERMES_MEMORY_INSTRUMENTATION
 }
 
-void HeapProfilerDomainAgent::sendSnapshot(int reqId, bool reportProgress) {
+void HeapProfilerDomainAgent::sendSnapshot(
+    int reqId,
+    bool reportProgress,
+    bool captureNumericValue) {
   if (reportProgress) {
     // A progress notification with finished = true indicates the
     // snapshot has been captured and is ready to be sent.  Our
@@ -100,7 +106,8 @@ void HeapProfilerDomainAgent::sendSnapshot(int reqId, bool reportProgress) {
           return true;
         });
 
-    runtime_.instrumentation().createSnapshotToStream(cos);
+    runtime_.instrumentation().createSnapshotToStream(
+        cos, {captureNumericValue});
   }
   sendResponseToClient(m::makeOkResponse(reqId));
 }
@@ -238,7 +245,10 @@ void HeapProfilerDomainAgent::stopTrackingHeapObjects(
 
   runtime_.instrumentation().stopTrackingHeapObjectStackTraces();
   trackingHeapObjectStackTraces_ = false;
-  sendSnapshot(req.id, req.reportProgress && *req.reportProgress);
+  sendSnapshot(
+      req.id,
+      req.reportProgress && *req.reportProgress,
+      req.captureNumericValue && *req.captureNumericValue);
 #else
   sendResponseToClient(m::makeErrorResponse(
       req.id, m::ErrorCode::InvalidRequest, kNoInstrumentation));

API/hermes/cdp/HeapProfilerDomainAgent.h

@@ -55,7 +55,7 @@ class HeapProfilerDomainAgent : public DomainAgent {
   void stopSampling(const m::heapProfiler::StopSamplingRequest &req);
 
  private:
-  void sendSnapshot(int reqId, bool reportProgress);
+  void sendSnapshot(int reqId, bool reportProgress, bool captureNumericValue);
 
   HermesRuntime &runtime_;
 

unittests/API/CDPAgentTest.cpp

@@ -17,6 +17,7 @@
 #include <hermes/CompileJS.h>
 #include <hermes/Support/JSONEmitter.h>
 #include <hermes/Support/SerialExecutor.h>
+#include <hermes/VM/HeapSnapshot.h>
 #include <hermes/cdp/CDPAgent.h>
 #include <hermes/cdp/CDPDebugAPI.h>
 #include <hermes/cdp/JSONValueInterfaces.h>
@@ -149,7 +150,8 @@ class CDPAgentTest : public ::testing::Test {
   /// \p messageID specifies the id of the snapshot request.
   /// \p ignoreTrackingNotifications indicates whether lastSeenObjectId and
   /// heapStatsUpdate notifications are tolerated before the snapshot arrives.
-  void expectHeapSnapshot(
+  /// \return the completed heap snapshot JSON object
+  JSONObject *expectHeapSnapshot(
       int messageID,
       bool ignoreTrackingNotifications = false);
 
@@ -381,7 +383,7 @@ void CDPAgentTest::expectErrorMessageContaining(
   ASSERT_NE(errorMessage.find(substring), std::string::npos);
 }
 
-void CDPAgentTest::expectHeapSnapshot(
+JSONObject *CDPAgentTest::expectHeapSnapshot(
     int messageID,
     bool ignoreTrackingNotifications) {
   // Expect chunk notifications until the snapshot object is complete. Fail if
@@ -398,12 +400,14 @@ void CDPAgentTest::expectHeapSnapshot(
       continue;
     }
 
-    ASSERT_EQ(method, "HeapProfiler.addHeapSnapshotChunk");
+    EXPECT_EQ(method, "HeapProfiler.addHeapSnapshotChunk");
     snapshot << jsonScope_.getString(note, {"params", "chunk"});
   } while (!jsonScope_.tryParseObject(snapshot.str()).has_value());
 
   // Expect the snapshot response after all chunks have been received.
   ensureOkResponse(waitForMessage(), messageID);
+
+  return jsonScope_.parseObject(snapshot.str());
 }
 
 jsi::Value CDPAgentTest::shouldStop(
@@ -3393,7 +3397,7 @@ TEST_F(CDPAgentTest, RuntimeValidatesExecutionContextId) {
   expectErrorMessageContaining(kExecutionContextSubstring, msgId++);
 }
 
-TEST_F(CDPAgentTest, HeapProfilerSnapshot) {
+TEST_F(CDPAgentTest, HeapProfilerSnapshotCaptureNumeric) {
   int msgId = 1;
 
 #ifdef HERMES_MEMORY_INSTRUMENTATION
@@ -3410,8 +3414,65 @@ TEST_F(CDPAgentTest, HeapProfilerSnapshot) {
   sendRequest(
       "HeapProfiler.takeHeapSnapshot", msgId, [](::hermes::JSONEmitter &json) {
         json.emitKeyValue("reportProgress", false);
+        json.emitKeyValue("captureNumericValue", true);
       });
-  expectHeapSnapshot(msgId);
+  JSONObject *root = expectHeapSnapshot(msgId);
+  const JSONArray &nodes = *llvh::cast<JSONArray>(root->at("nodes"));
+
+  bool found = false;
+  auto nodesIt = nodes.begin();
+  const auto nodesEnd = nodes.end();
+  while (nodesIt != nodesEnd) {
+    auto type = static_cast<::hermes::vm::HeapSnapshot::NodeType>(
+        static_cast<unsigned>(llvh::cast<JSONNumber>(*nodesIt)->getValue()));
+    if (type == ::hermes::vm::HeapSnapshot::NodeType::Number) {
+      found = true;
+    }
+    nodesIt += ::hermes::vm::HeapSnapshot::V8_SNAPSHOT_NODE_FIELD_COUNT;
+  }
+  EXPECT_TRUE(found);
+
+  // Expect no more chunks are pending.
+  expectNothing();
+#else
+  sendRequest(
+      "HeapProfiler.takeHeapSnapshot", msgId, [](::hermes::JSONEmitter &json) {
+        json.emitKeyValue("reportProgress", false);
+        json.emitKeyValue("captureNumericValue", true);
+      });
+  expectErrorMessageContaining(kMemoryInstrumentationSubstring, msgId);
+#endif // HERMES_MEMORY_INSTRUMENTATION
+}
+
+TEST_F(CDPAgentTest, HeapProfilerSnapshotNoNumeric) {
+  int msgId = 1;
+
+#ifdef HERMES_MEMORY_INSTRUMENTATION
+  auto setStopFlag = llvh::make_scope_exit([this] {
+    // break out of loop
+    stopFlag_.store(true);
+  });
+
+  scheduleScript(R"(
+      while(!shouldStop());
+  )");
+
+  // Request a heap snapshot and expect it to arrive.
+  // Expect captureNumericValue to default to false when not provided.
+  sendRequest(
+      "HeapProfiler.takeHeapSnapshot", msgId, [](::hermes::JSONEmitter &json) {
+        json.emitKeyValue("reportProgress", false);
+      });
+  JSONObject *root = expectHeapSnapshot(msgId);
+  const JSONArray &nodes = *llvh::cast<JSONArray>(root->at("nodes"));
+  auto nodesIt = nodes.begin();
+  const auto nodesEnd = nodes.end();
+  while (nodesIt != nodesEnd) {
+    auto type = static_cast<::hermes::vm::HeapSnapshot::NodeType>(
+        static_cast<unsigned>(llvh::cast<JSONNumber>(*nodesIt)->getValue()));
+    EXPECT_NE(type, ::hermes::vm::HeapSnapshot::NodeType::Number);
+    nodesIt += ::hermes::vm::HeapSnapshot::V8_SNAPSHOT_NODE_FIELD_COUNT;
+  }
 
   // Expect no more chunks are pending.
   expectNothing();