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"
+#include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
 
-#if !defined(NO_TCMALLOC) && defined(OS_LINUX)
-#include "third_party/tcmalloc/chromium/src/gperftools/heap-profiler.h"
-#endif  // !defined(NO_TCMALLOC) && defined(OS_LINUX)
+#if defined(USE_TCMALLOC) && (defined(OS_LINUX) || defined(OS_ANDROID))
 
 namespace {
 
 const char kMemoryBenchmarkingExtensionName[] = "v8/MemoryBenchmarking";
 
 }
 
 namespace {
 
 class MemoryBenchmarkingWrapper : public v8::Extension {
@@ skipping 21 matching lines @@
     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 v8::Handle<v8::Value> HeapProfilerDumpBrowser() {
+    base::FilePath dump_file_name;
+
+    content::RenderThreadImpl::current()->Send(
+        new MemoryBenchmarkHostMsg_HeapProfilerDump(&dump_file_name));
+    return v8::String::New(dump_file_name.value().c_str(),
+                           dump_file_name.value().length());
   }
 
   static v8::Handle<v8::Value> HeapProfilerDump(const v8::Arguments& args) {
-#if !defined(NO_TCMALLOC) && defined(OS_LINUX)
     char dumped_filename_buffer[1000];
     std::string reason("benchmarking_extension");
     if (args.Length() && args[0]->IsString())
       reason = *v8::String::AsciiValue(args[0]);
+    if (reason == "browser")

[Dai Mikurube (NOT FULLTIME), 2013/05/14 20:15:08]

Ahh, sorry, I overlooked the important part.  I forgot that the old
HeapProfilerDump() has already had an argument "reason".

Actually, I thought to add a new argument like "process_type".  If keeping
consistency with the old PyAuto API, the arguments would be:

HeapProfilerDump(process_type, reason)

It is not consistent with the current V8 API, but I think it's acceptable since
no one is using the V8 API yet.

+      return HeapProfilerDumpBrowser();
     ::HeapProfilerDumpWithFileName(reason.c_str(),

[palmer, 2013/05/10 19:53:53]

So, the renderer asks the browser for a FilePath (not ideal), and then calls
::HeapProfilerDumpWithFileName with the pathname of the FilePath.

In theory, that shouldn't work because the renderer should be sandboxed and
unable to open files. (::HeapProfilerDumpWithFileName ultimately does try to
directly open the pathname; see
third_party/tcmalloc/chromium/src/heap-profiler.cc.)

Also in theory, nothing strictly requires the renderer to open the FilePath that
the browser gave it. If the renderer can open files at all, it can open whatever
pathname it wants; the browser has given advice rather than set effective
policy.

Have you tested this and found that the renderer can in fact open files? Because
that would be a bug...

(Not your fault or problem, but ::HeapProfilerDumpWithFileName is incorrectly
declared as taking an int, rather than a size_t, for |filename_buffer_length|.
Ironically, in the implementation, that int gets cast back to a size_t...)

[Dai Mikurube (NOT FULLTIME), 2013/05/10 20:41:30]

Yes, this is used under a very limited situation, much detailed memory profiling
with using tcmalloc's heap profiler.  Deep Memory Profiler
(http://dev.chromium.org/developers/deep-memory-profiler) is an example of this.
 It is used in some buildbots (the "chromium.endure" waterfall, and more in
future) and in developer's environment with a command line option --no-sandbox.
The reason why the filename is returned is to give the filename to the test
runner.  The person who ran the test would want the filename dumped by the
browser process.  (The filename is decided by tcmalloc's heap profiler...  No
other way to know the dumped filename.)

                                    dumped_filename_buffer,
                                    sizeof(dumped_filename_buffer));
     return v8::String::New(dumped_filename_buffer);
-#endif  // !defined(NO_TCMALLOC) && defined(OS_LINUX)
-    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))