Report utility process JS memory in task manager.

chrome/utility/chrome_content_utility_client.cc

 // Copyright (c) 2012 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 "chrome/utility/chrome_content_utility_client.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted.h"
@@ skipping 10 matching lines @@
 #include "courgette/courgette.h"
 #include "courgette/third_party/bsdiff.h"
 #include "ipc/ipc_channel.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/zlib/google/zip.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/geometry/size.h"
 
 #if !defined(OS_ANDROID)
+#include "chrome/common/resource_usage_reporter.mojom.h"
 #include "chrome/utility/profile_import_handler.h"
 #include "net/proxy/mojo_proxy_resolver_factory_impl.h"
+#include "net/proxy/proxy_resolver_v8.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
 #endif
 
 #if defined(OS_ANDROID) && defined(USE_SECCOMP_BPF)
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/utility/font_cache_handler_win.h"
 #include "chrome/utility/shell_handler_win.h"
 #endif
@@ skipping 37 matching lines @@
 
 #if !defined(OS_ANDROID)
 void CreateProxyResolverFactory(
     mojo::InterfaceRequest<net::interfaces::ProxyResolverFactory> request) {
   // MojoProxyResolverFactoryImpl is strongly bound to the Mojo message pipe it
   // is connected to. When that message pipe is closed, either explicitly on the
   // other end (in the browser process), or by a connection error, this object
   // will be destroyed.
   new net::MojoProxyResolverFactoryImpl(request.Pass());
 }
+
+class ResourceUsageReporterImpl : public ResourceUsageReporter {
+ public:
+  explicit ResourceUsageReporterImpl(
+      mojo::InterfaceRequest<ResourceUsageReporter> req)
+      : binding_(this, req.Pass()) {}
+  ~ResourceUsageReporterImpl() override {}
+
+ private:
+  void GetUsageData(
+      const mojo::Callback<void(ResourceUsageDataPtr)>& callback) override {
+    ResourceUsageDataPtr data = ResourceUsageData::New();
+    size_t total_heap_size = net::ProxyResolverV8::GetTotalHeapSize();

[jam, 2015/05/12 16:12:23]

so this looks like a general purpose interface to get JS memory usage. however
it only works when the utility process is hosting PAC?

can this be queried directly from v8 so that it always works?

[Anand Mistry (off Chromium), 2015/05/13 00:42:11]

Yes.
I wanted to, but memory usage is queried from an Isolate, and from what I can
tell, there's no way to enumerate all the Isolates in a process. In this case,
ProxyResolverV8::Get*HeapSize() queries its internal Isolate. If anything else
uses V8, it would need to be queried explicitly. That, or adding the ability to
enumerate Isolates to V8.

[jam, 2015/05/15 06:54:22]

hmm, then perhaps this method should be called GetPACJSUsageData... it seem a
bit misleading otherwise.

have you checked with a v8 expert if there are any other ways?

[Anand Mistry (off Chromium), 2015/05/15 07:25:41]

Except that https://codereview.chromium.org/1081323003/ uses the same function
to present renderer process JS heap usage. Also, my understanding is that the
utility process doesn't have any other v8 usage at the moment, and from a user's
perspective, there's no change for non-pac utility processes. Of course, that
could change and if it does, this function should be extended to support that.
No. My plan was to get the PAC use case working so we can launch out-of-process
pac. But I'll bring it up with the V8 folks to see if there's a more generic way
of doing this. It would be nice since it's really messy in the renderer process.

[Anand Mistry (off Chromium), 2015/05/19 04:30:50]

I asked the V8 folks about this and the response is no, there's no way to do
this. Each Isolate is independent and V8 doesn't know about them. There's no way
to enumerate them or get the total memory usage.

[jam, 2015/05/19 16:11:46]

I see, ok thanks for checking. I don't want to block the awesome out of process
PAC work, so ok for now.

[jam, 2015/05/19 16:11:46]

My comment is about net::ProxyResolverV8::GetTotalHeapSize

+    if (total_heap_size) {
+      data->reports_v8_stats = true;
+      data->v8_memory_allocated = total_heap_size;
+      data->v8_memory_used = net::ProxyResolverV8::GetUsedHeapSize();
+    }
+    callback.Run(data.Pass());
+  }
+
+  mojo::StrongBinding<ResourceUsageReporter> binding_;
+};
+
+void CreateResourceUsageReporter(
+    mojo::InterfaceRequest<ResourceUsageReporter> request) {
+  new ResourceUsageReporterImpl(request.Pass());
+}
 #endif  // OS_ANDROID
 
 }  // namespace
 
 int64_t ChromeContentUtilityClient::max_ipc_message_size_ =
     IPC::Channel::kMaximumMessageSize;
 
 ChromeContentUtilityClient::ChromeContentUtilityClient()
     : filter_messages_(false) {
 #if !defined(OS_ANDROID)
@@ skipping 80 matching lines @@
   }
 
   return handled;
 }
 
 void ChromeContentUtilityClient::RegisterMojoServices(
     content::ServiceRegistry* registry) {
 #if !defined(OS_ANDROID)
   registry->AddService<net::interfaces::ProxyResolverFactory>(
       base::Bind(CreateProxyResolverFactory));
+  registry->AddService<ResourceUsageReporter>(
+      base::Bind(CreateResourceUsageReporter));
 #endif
 }
 
 // static
 void ChromeContentUtilityClient::PreSandboxStartup() {
 #if defined(ENABLE_EXTENSIONS)
   extensions::ExtensionsHandler::PreSandboxStartup();
 #endif
 
 #if defined(ENABLE_MDNS)
@@ skipping 202 matching lines @@
     const std::string& mime_type, int64 total_size, bool get_attached_images) {
   // Only one IPCDataSource may be created and added to the list of handlers.
   metadata::IPCDataSource* source = new metadata::IPCDataSource(total_size);
   handlers_.push_back(source);
 
   metadata::MediaMetadataParser* parser = new metadata::MediaMetadataParser(
       source, mime_type, get_attached_images);
   parser->Start(base::Bind(&FinishParseMediaMetadata, base::Owned(parser)));
 }
 #endif