Adds chrome.memoryBenchmarking.heapProfilerDump for the browser process.

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/string_util.h"
-#include "content/public/renderer/render_thread.h"
+#include "content/common/memory_benchmark_messages.h"
+#include "content/renderer/render_thread_impl.h"
 
-#if !defined(NO_TCMALLOC) && defined(OS_LINUX)
+#if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
+
 #include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
-#endif  // !defined(NO_TCMALLOC) && defined(OS_LINUX)
 
 namespace {
 
 const char kMemoryBenchmarkingExtensionName[] = "v8/MemoryBenchmarking";
 
 }
 
 namespace {
 
 class MemoryBenchmarkingWrapper : public v8::Extension {
  public:
   MemoryBenchmarkingWrapper() :
       v8::Extension(kMemoryBenchmarkingExtensionName,
         "if (typeof(chrome) == 'undefined') {"
         "  chrome = {};"
         "};"
         "if (typeof(chrome.memoryBenchmarking) == 'undefined') {"
         "  chrome.memoryBenchmarking = {};"
         "};"
         "chrome.memoryBenchmarking.isHeapProfilerRunning = function() {"
         "  native function IsHeapProfilerRunning();"
         "  return IsHeapProfilerRunning();"
         "};"
-        "chrome.memoryBenchmarking.heapProfilerDump = function(reason) {"
+        "chrome.memoryBenchmarking.heapProfilerDump = "
+        "      function(process_type, reason) {"
         "  native function HeapProfilerDump();"
-        "  HeapProfilerDump(reason);"
+        "  HeapProfilerDump(process_type, reason);"
         "};"
         ) {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(v8::String::New("IsHeapProfilerRunning")))
       return v8::FunctionTemplate::New(IsHeapProfilerRunning);
     else if (name->Equals(v8::String::New("HeapProfilerDump")))
       return v8::FunctionTemplate::New(HeapProfilerDump);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static v8::Handle<v8::Value> IsHeapProfilerRunning(
       const v8::Arguments& args) {
-#if !defined(NO_TCMALLOC) && defined(OS_LINUX)
     return v8::Boolean::New(::IsHeapProfilerRunning());
-#else
-    return v8::Boolean::New(false);
-#endif  // !defined(NO_TCMALLOC) && defined(OS_LINUX)
+  }
+
+  static void HeapProfilerDumpBrowser(const std::string& reason) {

[palmer, 2013/05/15 20:27:50]

What is the range of possible |reason|s? Normally I'd want to use an enum, and
stringify it in a trustworthy place, only where needed.

[Dai Mikurube (NOT FULLTIME), 2013/05/15 22:36:07]

It can be any string, and it has no effects on any behavior.

This |reason| is just a message for tcmalloc'c HeapProfilerDump and it's only
logged.  It is used like:
(See
https://code.google.com/p/gperftools/source/browse/trunk/src/gperftools/heap-...)

+    content::RenderThreadImpl::current()->Send(
+        new MemoryBenchmarkHostMsg_HeapProfilerDump(reason));
   }

[piman, 2013/05/15 19:18:54]

nit: you inlined this function into HeapProfilerDump. Either keep it and call
it, or remove it?

[bulach, 2013/05/16 08:29:09]

ops, sorry, I forgot to remove. done.

 
   static v8::Handle<v8::Value> HeapProfilerDump(const v8::Arguments& args) {
-#if !defined(NO_TCMALLOC) && defined(OS_LINUX)
+    std::string process_type;
+    if (args.Length() && args[0]->IsString())
+      process_type = *v8::String::AsciiValue(args[0]);
     std::string reason("benchmarking_extension");
-    if (args.Length() && args[0]->IsString())
-      reason = *v8::String::AsciiValue(args[0]);
-    ::HeapProfilerDump(reason.c_str());
-#endif  // !defined(NO_TCMALLOC) && defined(OS_LINUX)
+    if (args.Length() > 1 && args[1]->IsString())
+      reason = *v8::String::AsciiValue(args[1]);
+    if (process_type == "browser") {
+      content::RenderThreadImpl::current()->Send(
+          new MemoryBenchmarkHostMsg_HeapProfilerDump(reason));
+    } else {
+      ::HeapProfilerDump(reason.c_str());
+    }
     return v8::Undefined();
   }
 };
 
 }  // namespace
 
 namespace content {
 
 v8::Extension* MemoryBenchmarkingExtension::Get() {
   return new MemoryBenchmarkingWrapper();
 }
 
 }  // namespace content
+
+#endif  // defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))