Report utility process JS memory in task manager.

chrome/browser/task_manager/child_process_resource_provider.cc

 // Copyright 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 "chrome/browser/task_manager/child_process_resource_provider.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/task_manager/resource_provider.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/process_resource_usage.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
+using content::ProcessResourceUsage;
 using content::WebContents;
 
 namespace task_manager {
 
 class ChildProcessResource : public Resource {
  public:
-  ChildProcessResource(int process_type,
-                       const base::string16& name,
-                       base::ProcessHandle handle,
-                       int unique_process_id);
+  ChildProcessResource(
+      int process_type,
+      const base::string16& name,
+      base::ProcessHandle handle,
+      int unique_process_id,
+      const scoped_refptr<ProcessResourceUsage>& resource_usage);
   ~ChildProcessResource() override;
 
   // Resource methods:
   base::string16 GetTitle() const override;
   base::string16 GetProfileName() const override;
   gfx::ImageSkia GetIcon() const override;
   base::ProcessHandle GetProcess() const override;
   int GetUniqueChildProcessId() const override;
   Type GetType() const override;
   bool SupportNetworkUsage() const override;
   void SetSupportNetworkUsage() override;
+  void Refresh() override;
+  bool ReportsV8MemoryStats() const override;
+  size_t GetV8MemoryAllocated() const override;
+  size_t GetV8MemoryUsed() const override;
 
   // Returns the pid of the child process.
   int process_id() const { return pid_; }
 
  private:
   // Returns a localized title for the child process.  For example, a plugin
   // process would be "Plugin: Flash" when name is "Flash".
   base::string16 GetLocalizedTitle() const;
 
   int process_type_;
   base::string16 name_;
   base::ProcessHandle handle_;
   int pid_;
   int unique_process_id_;
   mutable base::string16 title_;
   bool network_usage_support_;
+  scoped_refptr<ProcessResourceUsage> resource_usage_;
 
   // The icon painted for the child processs.
   // TODO(jcampan): we should have plugin specific icons for well-known
   // plugins.
   static gfx::ImageSkia* default_icon_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildProcessResource);
 };
 
 gfx::ImageSkia* ChildProcessResource::default_icon_ = NULL;
 
 ChildProcessResource::ChildProcessResource(
     int process_type,
     const base::string16& name,
     base::ProcessHandle handle,
-    int unique_process_id)
+    int unique_process_id,
+    const scoped_refptr<ProcessResourceUsage>& resource_usage)
     : process_type_(process_type),
       name_(name),
       handle_(handle),
       unique_process_id_(unique_process_id),
-      network_usage_support_(false) {
+      network_usage_support_(false),
+      resource_usage_(resource_usage) {

[ncarter (slow), 2015/05/01 21:37:58]

Can you come up with a TaskManagerBrowserTest for the resource usage reporting?
This is a little more work than usual because afaik we don't have much test
coverage currently for any of the Child process reporting in the task manager.
But it should be straightforward... here's some hints.

Assuming it isn't reverted again, TaskManagerBrowserTest.WebWorkerJSHeapMemory (
pending rewrite: WebWorkerhttps://codereview.chromium.org/1090433002/ ) can be a
good baseline. The recipe is something like:

- If you have one handy, copy code from some non-taskmanager browsertest that
creates a child process that would have a v8 instance.
- Add a MatchUtilityProcess() or whatever method to
task_manager_browsertest_util.cc, assuming there's not one there already.
- Force the child process to do something that would cause at least X memory to
be consumed (ideally X is significantly larger than v8's initial memory
footprint, though if X needs to be zero, that is probably decent enough).
- Wait for the task manager rows.

For bonus points you can also:
 [1] Hide and then show the task manager, and assert that the child process
remains. This is valuable because the "loop over existing child processes" and
"listen for new child processes" codepaths are different enough to be worth
exercising both.
 [2] test the KillProcess codepath (make sure the task manager row disappears
when a child process dies).

Let me know if you want help -- I'll happily write the test for you if you can
point me at example code to force creation of the appropriate child/utility
process type.

   // We cache the process id because it's not cheap to calculate, and it won't
   // be available when we get the plugin disconnected notification.
   pid_ = base::GetProcId(handle);
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGINS_FAVICON);
     // TODO(jabdelmalek): use different icon for web workers.
   }
 }
 
@@ skipping 100 matching lines @@
     case content::PROCESS_TYPE_MAX:
       NOTREACHED();
       break;
     case content::PROCESS_TYPE_UNKNOWN:
       NOTREACHED() << "Need localized name for child process type.";
   }
 
   return title;
 }
 
+void ChildProcessResource::Refresh() {
+  if (resource_usage_)
+    resource_usage_->Refresh();
+}
+
+bool ChildProcessResource::ReportsV8MemoryStats() const {
+  if (resource_usage_)
+    return resource_usage_->ReportsV8MemoryStats();
+  return false;
+}
+
+size_t ChildProcessResource::GetV8MemoryAllocated() const {
+  if (resource_usage_)
+    return resource_usage_->GetV8MemoryAllocated();
+  return 0;
+}
+
+size_t ChildProcessResource::GetV8MemoryUsed() const {
+  if (resource_usage_)
+    return resource_usage_->GetV8MemoryUsed();
+  return 0;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ChildProcessResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
 ChildProcessResourceProvider::
     ChildProcessResourceProvider(TaskManager* task_manager)
     : task_manager_(task_manager),
       updating_(false) {
 }
 
@@ skipping 75 matching lines @@
   DCHECK(pid_iter != pid_to_resources_.end());
   if (pid_iter != pid_to_resources_.end())
     pid_to_resources_.erase(pid_iter);
 
   // Finally, delete the resource.
   delete resource;
 }
 
 void ChildProcessResourceProvider::AddToTaskManager(
     const content::ChildProcessData& child_process_data) {
-  ChildProcessResource* resource =
-      new ChildProcessResource(
-          child_process_data.process_type,
-          child_process_data.name,
-          child_process_data.handle,
-          child_process_data.id);
+  ChildProcessResource* resource = new ChildProcessResource(
+      child_process_data.process_type, child_process_data.name,
+      child_process_data.handle, child_process_data.id,
+      child_process_data.process_resource_usage);
   resources_[child_process_data.handle] = resource;
   pid_to_resources_[resource->process_id()] = resource;
   task_manager_->AddResource(resource);
 }
 
 // The ChildProcessData::Iterator has to be used from the IO thread.
 void ChildProcessResourceProvider::RetrieveChildProcessData() {
   std::vector<content::ChildProcessData> child_processes;
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     // Only add processes which are already started, since we need their handle.
@@ skipping 13 matching lines @@
 // This is called on the UI thread.
 void ChildProcessResourceProvider::ChildProcessDataRetreived(
     const std::vector<content::ChildProcessData>& child_processes) {
   for (size_t i = 0; i < child_processes.size(); ++i)
     AddToTaskManager(child_processes[i]);
 
   task_manager_->model()->NotifyDataReady();
 }
 
 }  // namespace task_manager