feat: add process.takeHeapSnapshot() / webContents.takeHeapSnapshot()

atom/browser/api/atom_api_web_contents.cc

@@ -20,6 +20,8 @@
 #include "atom/browser/lib/bluetooth_chooser.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/net/atom_network_delegate.h"
+#include "atom/common/api/heap_snapshot_output_stream.h"
+#include "base/threading/thread_restrictions.h"
 #if defined(ENABLE_OSR)
 #include "atom/browser/osr/osr_output_device.h"
 #include "atom/browser/osr/osr_render_widget_host_view.h"
@@ -299,6 +301,10 @@ struct WebContents::FrameDispatchHelper {
                              IPC::Message* message) {
     api_web_contents->OnRendererMessageSync(rfh, channel, args, message);
   }
+
+  void OnCreateHeapSnapshotFile(IPC::Message* message) {
+    api_web_contents->OnCreateHeapSnapshotFile(rfh, message);
+  }
 };
 
 WebContents::WebContents(v8::Isolate* isolate,
@@ -1036,6 +1042,9 @@ bool WebContents::OnMessageReceived(const IPC::Message& message,
     IPC_MESSAGE_HANDLER(AtomAutofillFrameHostMsg_ShowPopup, ShowAutofillPopup)
     IPC_MESSAGE_HANDLER(AtomAutofillFrameHostMsg_HidePopup, HideAutofillPopup)
 #endif
+    IPC_MESSAGE_FORWARD_DELAY_REPLY(
+        AtomFrameHostMsg_CreateHeapSnapshotFile, &helper,
+        FrameDispatchHelper::OnCreateHeapSnapshotFile)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -2108,6 +2117,21 @@ void WebContents::OnRendererMessageTo(content::RenderFrameHost* frame_host,
   }
 }
 
+void WebContents::OnCreateHeapSnapshotFile(content::RenderFrameHost* frame_host,
+                                           IPC::Message* message) {
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+
+  auto file_path = HeapSnapshotOutputStream::GetFilePath();
+
+  base::File file(file_path,
+                  base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+
+  AtomFrameHostMsg_CreateHeapSnapshotFile::WriteReplyParams(
+      message, file_path, IPC::TakePlatformFileForTransit(std::move(file)));
+
+  frame_host->Send(message);
+}
+
 // static
 mate::Handle<WebContents> WebContents::CreateFrom(
     v8::Isolate* isolate,

atom/browser/api/atom_api_web_contents.h

@@ -434,6 +434,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
                            const std::string& channel,
                            const base::ListValue& args);
 
+  void OnCreateHeapSnapshotFile(content::RenderFrameHost* frame_host,
+                                IPC::Message* message);
+
   // Called when received a synchronous message from renderer to
   // set temporary zoom level.
   void OnSetTemporaryZoomLevel(content::RenderFrameHost* frame_host,

atom/common/api/api_messages.h

@@ -10,6 +10,7 @@
 #include "content/public/common/common_param_traits.h"
 #include "content/public/common/referrer.h"
 #include "ipc/ipc_message_macros.h"
+#include "ipc/ipc_platform_file.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/ipc/gfx_param_traits.h"
 #include "url/gurl.h"
@@ -76,3 +77,7 @@ IPC_SYNC_MESSAGE_ROUTED0_1(AtomFrameHostMsg_GetZoomLevel, double /* result */)
 IPC_MESSAGE_ROUTED2(AtomFrameHostMsg_PDFSaveURLAs,
                     GURL /* url */,
                     content::Referrer /* referrer */)
+
+IPC_SYNC_MESSAGE_ROUTED0_2(AtomFrameHostMsg_CreateHeapSnapshotFile,
+                           base::FilePath /* file_path */,
+                           IPC::PlatformFileForTransit /* file_handle */)

atom/common/api/atom_bindings.cc

@@ -8,16 +8,22 @@
 #include <iostream>
 #include <string>
 
+#include "atom/common/api/api_messages.h"
+#include "atom/common/api/heap_snapshot_output_stream.h"
 #include "atom/common/api/locker.h"
 #include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/node_includes.h"
+#include "atom/renderer/api/atom_api_renderer_ipc.h"
 #include "base/logging.h"
 #include "base/process/process_info.h"
 #include "base/process/process_metrics_iocounters.h"
 #include "base/sys_info.h"
+#include "content/public/renderer/render_frame.h"
 #include "native_mate/dictionary.h"
+#include "v8/include/v8-profiler.h"
 
 namespace atom {
 
@@ -60,6 +66,7 @@ void AtomBindings::BindTo(v8::Isolate* isolate, v8::Local<v8::Object> process) {
   dict.SetMethod("getCPUUsage", base::Bind(&AtomBindings::GetCPUUsage,
                                            base::Unretained(metrics_.get())));
   dict.SetMethod("getIOCounters", &GetIOCounters);
+  dict.SetMethod("takeHeapSnapshot", &TakeHeapSnapshot);
 #if defined(OS_POSIX)
   dict.SetMethod("setFdLimit", &base::SetFdLimit);
 #endif
@@ -238,4 +245,53 @@ v8::Local<v8::Value> AtomBindings::GetIOCounters(v8::Isolate* isolate) {
   return dict.GetHandle();
 }
 
+// static
+base::FilePath AtomBindings::TakeHeapSnapshot(v8::Isolate* isolate,
+                                              mate::Arguments* args) {
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+
+  auto file_path = HeapSnapshotOutputStream::GetFilePath();
+
+  base::File file(file_path,
+                  base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+
+  if (!file.IsValid()) {
+    auto* render_frame = GetCurrentRenderFrame();
+    if (!render_frame) {
+      args->ThrowError("takeHeapSnapshot failed");
+      return base::FilePath();
+    }
+
+    IPC::PlatformFileForTransit file_handle;
+    auto* message = new AtomFrameHostMsg_CreateHeapSnapshotFile(
+        render_frame->GetRoutingID(), &file_path, &file_handle);
+
+    if (!render_frame->Send(message)) {
+      args->ThrowError("takeHeapSnapshot failed");
+      return base::FilePath();
+    }
+
+    file = IPC::PlatformFileForTransitToFile(file_handle);
+  }
+
+  if (!file.IsValid()) {
+    args->ThrowError("takeHeapSnapshot failed - cannot create file");
+    return base::FilePath();
+  }
+
+  auto* snap = isolate->GetHeapProfiler()->TakeHeapSnapshot();
+
+  HeapSnapshotOutputStream stream(&file);
+  snap->Serialize(&stream, v8::HeapSnapshot::kJSON);
+
+  const_cast<v8::HeapSnapshot*>(snap)->Delete();
+
+  if (!stream.IsComplete()) {
+    args->ThrowError("takeHeapSnapshot failed - snapshot incomplete");
+    return base::FilePath();
+  }
+
+  return file_path;
+}
+
 }  // namespace atom

atom/common/api/atom_bindings.h

@@ -8,6 +8,7 @@
 #include <list>
 #include <memory>
 
+#include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string16.h"
@@ -43,6 +44,8 @@ class AtomBindings {
   static v8::Local<v8::Value> GetCPUUsage(base::ProcessMetrics* metrics,
                                           v8::Isolate* isolate);
   static v8::Local<v8::Value> GetIOCounters(v8::Isolate* isolate);
+  static base::FilePath TakeHeapSnapshot(v8::Isolate* isolate,
+                                         mate::Arguments* args);
 
  private:
   void ActivateUVLoop(v8::Isolate* isolate);

atom/common/api/heap_snapshot_output_stream.cc

@@ -0,0 +1,52 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/common/api/heap_snapshot_output_stream.h"
+
+#include "base/path_service.h"
+#include "base/strings/stringprintf.h"
+#include "brightray/browser/brightray_paths.h"
+#include "uv.h"  // NOLINT(build/include)
+
+namespace atom {
+
+HeapSnapshotOutputStream::HeapSnapshotOutputStream(base::File* file)
+    : file_(file) {
+  DCHECK(file_);
+}
+
+bool HeapSnapshotOutputStream::IsComplete() const {
+  return is_complete_;
+}
+
+int HeapSnapshotOutputStream::GetChunkSize() {
+  return 65536;
+}
+
+void HeapSnapshotOutputStream::EndOfStream() {
+  is_complete_ = true;
+}
+
+v8::OutputStream::WriteResult HeapSnapshotOutputStream::WriteAsciiChunk(
+    char* data,
+    int size) {
+  auto bytes_written = file_->WriteAtCurrentPos(data, size);
+  return bytes_written == size ? kContinue : kAbort;
+}
+
+// static
+base::FilePath HeapSnapshotOutputStream::GetFilePath() {
+  base::FilePath user_data;
+  if (!PathService::Get(brightray::DIR_USER_DATA, &user_data))
+    return base::FilePath();
+
+  auto now = uv_hrtime();
+  auto sec = static_cast<unsigned int>(now / 1000000);
+  auto usec = static_cast<unsigned int>(now % 1000000);
+  auto filename = base::StringPrintf("heapdump-%u-%u.heapsnapshot", sec, usec);
+
+  return user_data.AppendASCII(filename.c_str());
+}
+
+}  // namespace atom

atom/common/api/heap_snapshot_output_stream.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_API_HEAP_SNAPSHOT_OUTPUT_STREAM_H_
+#define ATOM_COMMON_API_HEAP_SNAPSHOT_OUTPUT_STREAM_H_
+
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "v8/include/v8-profiler.h"
+
+namespace atom {
+
+class HeapSnapshotOutputStream : public v8::OutputStream {
+ public:
+  explicit HeapSnapshotOutputStream(base::File* file);
+
+  bool IsComplete() const;
+
+  // v8::OutputStream
+  int GetChunkSize() override;
+  void EndOfStream() override;
+  v8::OutputStream::WriteResult WriteAsciiChunk(char* data, int size) override;
+
+  static base::FilePath GetFilePath();
+
+ private:
+  base::File* file_ = nullptr;
+  bool is_complete_ = false;
+};
+
+}  // namespace atom
+
+#endif  // ATOM_COMMON_API_HEAP_SNAPSHOT_OUTPUT_STREAM_H_

atom/common/api/remote_object_freer.cc

@@ -5,27 +5,13 @@
 #include "atom/common/api/remote_object_freer.h"
 
 #include "atom/common/api/api_messages.h"
+#include "atom/renderer/api/atom_api_renderer_ipc.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/public/renderer/render_frame.h"
-#include "third_party/blink/public/web/web_local_frame.h"
-
-using blink::WebLocalFrame;
 
 namespace atom {
 
-namespace {
-
-content::RenderFrame* GetCurrentRenderFrame() {
-  WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
-  if (!frame)
-    return nullptr;
-
-  return content::RenderFrame::FromWebFrame(frame);
-}
-
-}  // namespace
-
 // static
 void RemoteObjectFreer::BindTo(v8::Isolate* isolate,
                                v8::Local<v8::Object> target,

atom/renderer/api/atom_api_renderer_ipc.cc

@@ -17,8 +17,6 @@ using content::RenderFrame;
 
 namespace atom {
 
-namespace api {
-
 RenderFrame* GetCurrentRenderFrame() {
   WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
   if (!frame)
@@ -27,6 +25,8 @@ RenderFrame* GetCurrentRenderFrame() {
   return RenderFrame::FromWebFrame(frame);
 }
 
+namespace api {
+
 void Send(mate::Arguments* args,
           const std::string& channel,
           const base::ListValue& arguments) {

atom/renderer/api/atom_api_renderer_ipc.h

@@ -10,8 +10,14 @@
 #include "base/values.h"
 #include "native_mate/arguments.h"
 
+namespace content {
+class RenderFrame;
+}
+
 namespace atom {
 
+content::RenderFrame* GetCurrentRenderFrame();
+
 namespace api {
 
 void Send(mate::Arguments* args,

atom/renderer/atom_sandboxed_renderer_client.cc

@@ -6,6 +6,7 @@
 
 #include "atom/common/api/api_messages.h"
 #include "atom/common/api/atom_bindings.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_bindings.h"
@@ -20,8 +21,8 @@
 #include "chrome/renderer/printing/print_web_view_helper.h"
 #include "content/public/renderer/render_frame.h"
 #include "native_mate/dictionary.h"
-#include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/blink.h"
+#include "third_party/blink/public/web/web_document.h"
 
 #include "atom/common/node_includes.h"
 #include "atom_natives.h"  // NOLINT: This file is generated with js2c
@@ -157,6 +158,7 @@ void AtomSandboxedRendererClient::InitializeBindings(
   b.SetMethod("getCPUUsage", base::Bind(&AtomBindings::GetCPUUsage,
                                         base::Unretained(metrics_.get())));
   b.SetMethod("getIOCounters", &AtomBindings::GetIOCounters);
+  b.SetMethod("takeHeapSnapshot", &AtomBindings::TakeHeapSnapshot);
 
   // Pass in CLI flags needed to setup the renderer
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();

docs/api/process.md

@@ -171,6 +171,16 @@ Returns `Object`:
 Returns an object giving memory usage statistics about the entire system. Note
 that all statistics are reported in Kilobytes.
 
+<!--
+### `process.takeHeapSnapshot()`
+
+Returns `String` - The file path of the saved V8 heap snapshot.
+
+Takes a V8 heap snapshot and saves it to the userData directory.
+Returns the file path of the saved file.
+An exception will be thrown in case of failure.
+-->
+
 ### `process.hang()`
 
 Causes the main thread of the current process hang.

docs/api/web-contents.md

@@ -1459,6 +1459,14 @@ Returns `Integer` - The Chromium internal `pid` of the associated renderer. Can
 be compared to the `frameProcessId` passed by frame specific navigation events
 (e.g. `did-frame-navigate`)
 
+#### `contents.takeHeapSnapshot()`
+
+Returns `Promise` - The file path of the saved V8 heap snapshot.
+
+Takes a V8 heap snapshot and saves it to the userData directory.
+The promise resolves with the file path of the saved file.
+The promise will be rejected in case of failure.
+
 ### Instance Properties
 
 #### `contents.id`