Add chrome.memoryBenchmarking.requestMemoryDump() API

content/renderer/memory_benchmarking_extension.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/memory_benchmarking_extension.h"
 
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/memory_dump_request_args.h"
 #include "content/common/memory_benchmark_messages.h"
 #include "content/renderer/chrome_object_extensions_utils.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gin/arguments.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 #if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 #endif
 
 namespace content {
 
+namespace {
+
+class CallbackWithContext {
+ public:
+  CallbackWithContext(v8::Isolate* isolate, v8::Local<v8::Function> callback)
+      : task_runner_(base::ThreadTaskRunnerHandle::Get()), isolate_(isolate) {
+    callback_.Reset(isolate, callback);
+    context_.Reset(isolate, isolate->GetCurrentContext());
+  }
+
+  virtual ~CallbackWithContext() {
+    callback_.Reset();
+    context_.Reset();
+  }
+
+  base::SingleThreadTaskRunner* task_runner() { return task_runner_.get(); }

[Primiano Tucci (use gerrit), 2015/07/24 14:29:14]

nit +const between ) and {

+
+  v8::Isolate* isolate() { return isolate_; }

[Primiano Tucci (use gerrit), 2015/07/24 14:29:14]

ditto (here and below)

+
+  v8::Local<v8::Function> GetCallback() {
+    return v8::Local<v8::Function>::New(isolate_, callback_);
+  }
+
+  v8::Local<v8::Context> GetContext() {
+    return v8::Local<v8::Context>::New(isolate_, context_);
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  v8::Isolate* isolate_;
+  v8::Persistent<v8::Function> callback_;
+  v8::Persistent<v8::Context> context_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallbackWithContext);
+};
+
+void OnMemoryDumpFinishedInternal(
+    scoped_ptr<CallbackWithContext> callback_with_context,
+    uint64 dump_guid,
+    bool success) {
+  DCHECK(callback_with_context->task_runner()->BelongsToCurrentThread());
+
+  v8::Isolate* isolate = callback_with_context->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(callback_with_context->GetContext());
+
+  v8::Local<v8::Function> callback = callback_with_context->GetCallback();
+  v8::Local<v8::Value> args[] = {
+      gin::StringToV8(isolate, base::StringPrintf("0x%" PRIx64, dump_guid)),
+      gin::Converter<bool>::ToV8(isolate, success)};
+
+  blink::WebLocalFrame* frame = blink::WebLocalFrame::frameForCurrentContext();
+  if (!frame)
+    return;
+
+  (void)frame->callFunctionEvenIfScriptDisabled(
+      callback, v8::Object::New(isolate), 2, args);
+}
+
+void OnMemoryDumpFinished(scoped_ptr<CallbackWithContext> callback_with_context,

[Primiano Tucci (use gerrit), 2015/07/24 14:29:14]

You don't need to split the function in OnMemoryDumpFinished + internal, are you
doing that just for the thread hopping?
Usually it is an accepted pattern in chrome to post to the function itself in
the right thread (without the extra layer of indirection).

+                          uint64 dump_guid,
+                          bool success) {
+  if (!callback_with_context->task_runner()->BelongsToCurrentThread()) {
+    callback_with_context->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&OnMemoryDumpFinishedInternal,
+                   base::Passed(&callback_with_context), dump_guid, success));
+    return;
+  }
+  OnMemoryDumpFinishedInternal(callback_with_context.Pass(), dump_guid,
+                               success);
+}
+
+}  // namespace
+
 gin::WrapperInfo MemoryBenchmarkingExtension::kWrapperInfo = {
     gin::kEmbedderNativeGin};
 
 // static
 void MemoryBenchmarkingExtension::Install(blink::WebFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
@@ skipping 14 matching lines @@
 
 MemoryBenchmarkingExtension::~MemoryBenchmarkingExtension() {}
 
 gin::ObjectTemplateBuilder
 MemoryBenchmarkingExtension::GetObjectTemplateBuilder(v8::Isolate* isolate) {
   return gin::Wrappable<MemoryBenchmarkingExtension>::GetObjectTemplateBuilder(
              isolate)
       .SetMethod("isHeapProfilerRunning",
                  &MemoryBenchmarkingExtension::IsHeapProfilerRunning)
       .SetMethod("heapProfilerDump",
-                 &MemoryBenchmarkingExtension::HeapProfilerDump);
+                 &MemoryBenchmarkingExtension::HeapProfilerDump)
+      .SetMethod("requestMemoryDump",
+                 &MemoryBenchmarkingExtension::RequestMemoryDump);
 }
 
 bool MemoryBenchmarkingExtension::IsHeapProfilerRunning() {
 #if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
   return ::IsHeapProfilerRunning();
 #else
   return false;
 #endif
 }
 
@@ skipping 10 matching lines @@
 #if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
   if (process_type == "browser") {
     content::RenderThreadImpl::current()->Send(
         new MemoryBenchmarkHostMsg_HeapProfilerDump(reason));
   } else {
     ::HeapProfilerDump(reason.c_str());
   }
 #endif
 }
 
+void MemoryBenchmarkingExtension::RequestMemoryDump(gin::Arguments* args) {
+  v8::Local<v8::Function> callback;
+  if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsFunction())
+    args->GetNext(&callback);
+
+  if (callback.IsEmpty()) {
+    base::trace_event::MemoryDumpManager::GetInstance()->RequestGlobalDump(
+        base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED);
+  } else {
+    scoped_ptr<CallbackWithContext> callback_with_context(
+        new CallbackWithContext(args->isolate(), callback));
+    base::trace_event::MemoryDumpManager::GetInstance()->RequestGlobalDump(
+        base::trace_event::MemoryDumpType::EXPLICITLY_TRIGGERED,
+        base::Bind(&OnMemoryDumpFinished,
+                   base::Passed(&callback_with_context)));
+  }
+}
+
 }  // namespace content