feat: add process.getHeapSnapshot()

atom/browser/api/atom_api_web_contents.cc

@@ -308,6 +308,10 @@ struct WebContents::FrameDispatchHelper {
                              IPC::Message* message) {
     api_web_contents->OnRendererMessageSync(rfh, channel, args, message);
   }
+
+  void OnCreateTemporaryFile(IPC::Message* message) {
+    api_web_contents->OnCreateTemporaryFile(rfh, message);
+  }
 };
 
 WebContents::WebContents(v8::Isolate* isolate,
@@ -1032,6 +1036,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_CreateTemporaryFile,
+                                    &helper,
+                                    FrameDispatchHelper::OnCreateTemporaryFile)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -2101,6 +2108,22 @@ void WebContents::OnRendererMessageTo(content::RenderFrameHost* frame_host,
   }
 }
 
+void WebContents::OnCreateTemporaryFile(content::RenderFrameHost* frame_host,
+                                        IPC::Message* message) {
+  base::ScopedAllowBlockingForTesting allow_blocking;
+
+  base::FilePath file_path;
+  base::CreateTemporaryFile(&file_path);
+
+  base::File file(file_path,
+                  base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+
+  AtomFrameHostMsg_CreateTemporaryFile::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

@@ -431,6 +431,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
                            const std::string& channel,
                            const base::ListValue& args);
 
+  void OnCreateTemporaryFile(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_CreateTemporaryFile,
+                           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/file_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 "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 "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "v8/include/v8-profiler.h"
 
 namespace atom {
 
@@ -54,6 +60,7 @@ void AtomBindings::BindTo(v8::Isolate* isolate, v8::Local<v8::Object> process) {
   dict.SetMethod("crash", &AtomBindings::Crash);
   dict.SetMethod("hang", &Hang);
   dict.SetMethod("log", &Log);
+  dict.SetMethod("getHeapSnapshot", &GetHeapSnapshot);
   dict.SetMethod("getHeapStatistics", &GetHeapStatistics);
   dict.SetMethod("getProcessMemoryInfo", &GetProcessMemoryInfo);
   dict.SetMethod("getCreationTime", &GetCreationTime);
@@ -129,6 +136,40 @@ void AtomBindings::Hang() {
     base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
 }
 
+// static
+base::FilePath AtomBindings::GetHeapSnapshot(v8::Isolate* isolate) {
+  auto* frame = blink::WebLocalFrame::FrameForCurrentContext();
+  if (!frame)
+    return base::FilePath();
+
+  auto* render_frame = content::RenderFrame::FromWebFrame(frame);
+  if (!render_frame)
+    return base::FilePath();
+
+  base::FilePath file_path;
+  IPC::PlatformFileForTransit file_handle;
+  auto* message = new AtomFrameHostMsg_CreateTemporaryFile(
+      render_frame->GetRoutingID(), &file_path, &file_handle);
+  if (!render_frame->Send(message))
+    return base::FilePath();
+
+  auto file = IPC::PlatformFileForTransitToFile(file_handle);
+  if (!file.IsValid())
+    return base::FilePath();
+
+  auto* snap = isolate->GetHeapProfiler()->TakeHeapSnapshot();
+
+  FileOutputStream stream(&file);
+  snap->Serialize(&stream, v8::HeapSnapshot::kJSON);
+
+  const_cast<v8::HeapSnapshot*>(snap)->Delete();
+
+  if (!stream.IsComplete())
+    return base::FilePath();
+
+  return file_path;
+}
+
 // static
 v8::Local<v8::Value> AtomBindings::GetHeapStatistics(v8::Isolate* isolate) {
   v8::HeapStatistics v8_heap_stats;

atom/common/api/atom_bindings.h

@@ -7,6 +7,7 @@
 
 #include <list>
 
+#include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string16.h"
@@ -35,6 +36,7 @@ class AtomBindings {
   static void Log(const base::string16& message);
   static void Crash();
   static void Hang();
+  static base::FilePath GetHeapSnapshot(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetHeapStatistics(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetProcessMemoryInfo(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetCreationTime(v8::Isolate* isolate);

atom/common/api/file_output_stream.cc

@@ -0,0 +1,29 @@
+// 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/file_output_stream.h"
+
+namespace atom {
+
+FileOutputStream::FileOutputStream(base::File* file) : file_(file) {}
+
+bool FileOutputStream::IsComplete() const {
+  return is_complete_;
+}
+
+int FileOutputStream::GetChunkSize() {
+  return 65536;
+}
+
+void FileOutputStream::EndOfStream() {
+  is_complete_ = true;
+}
+
+v8::OutputStream::WriteResult FileOutputStream::WriteAsciiChunk(char* data,
+                                                                int size) {
+  auto bytes_written = file_->WriteAtCurrentPos(data, size);
+  return bytes_written == size ? kContinue : kAbort;
+}
+
+}  // namespace atom

atom/common/api/file_output_stream.h

@@ -0,0 +1,32 @@
+// 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_FILE_OUTPUT_STREAM_H_
+#define ATOM_COMMON_API_FILE_OUTPUT_STREAM_H_
+
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "v8/include/v8-profiler.h"
+
+namespace atom {
+
+class FileOutputStream : public v8::OutputStream {
+ public:
+  explicit FileOutputStream(base::File* file);
+
+  bool IsComplete() const;
+
+  // v8::OutputStream
+  virtual int GetChunkSize();
+  virtual void EndOfStream();
+  virtual v8::OutputStream::WriteResult WriteAsciiChunk(char* data, int size);
+
+ private:
+  base::File* file_ = nullptr;
+  bool is_complete_ = false;
+};
+
+}  // namespace atom
+
+#endif  // ATOM_COMMON_API_FILE_OUTPUT_STREAM_H_

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"
@@ -152,6 +153,7 @@ void AtomSandboxedRendererClient::InitializeBindings(
   b.SetMethod("getExecPath", GetExecPath);
   b.SetMethod("getPid", &base::GetCurrentProcId);
   b.SetMethod("getResourcesPath", &NodeBindings::GetHelperResourcesPath);
+  b.SetMethod("getHeapSnapshot", &AtomBindings::GetHeapSnapshot);
   b.SetMethod("getHeapStatistics", &AtomBindings::GetHeapStatistics);
   b.SetMethod("getProcessMemoryInfo", &AtomBindings::GetProcessMemoryInfo);
   b.SetMethod("getSystemMemoryInfo", &AtomBindings::GetSystemMemoryInfo);

filenames.gypi

@@ -449,6 +449,8 @@
       'atom/common/api/event_emitter_caller.cc',
       'atom/common/api/event_emitter_caller.h',
       'atom/common/api/features.cc',
+      'atom/common/api/file_output_stream.cc',
+      'atom/common/api/file_output_stream.h',
       'atom/common/api/locker.cc',
       'atom/common/api/locker.h',
       'atom/common/api/object_life_monitor.cc',

lib/sandboxed_renderer/init.js

@@ -48,6 +48,7 @@ require('../renderer/web-frame-init')()
 const preloadProcess = new events.EventEmitter()
 preloadProcess.crash = () => binding.crash()
 preloadProcess.hang = () => binding.hang()
+preloadProcess.getHeapSnapshot = () => binding.getHeapSnapshot()
 preloadProcess.getHeapStatistics = () => binding.getHeapStatistics()
 preloadProcess.getProcessMemoryInfo = () => binding.getProcessMemoryInfo()
 preloadProcess.getSystemMemoryInfo = () => binding.getSystemMemoryInfo()