Add memory and CPU histogram for OOPIF

chrome/browser/performance_monitor/performance_monitor.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/browser/performance_monitor/performance_monitor.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/process/process_iterator.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_child_process_host.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/render_process_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_iterator.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/content_constants.h"
 #include "extensions/features/features.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #endif
 
 using content::BrowserThread;
 
 namespace performance_monitor {
 
 namespace {
 
 // The default interval at which PerformanceMonitor performs its timed
 // collections.
 const int kGatherIntervalInSeconds = 120;
 
 base::LazyInstance<PerformanceMonitor> g_monitor = LAZY_INSTANCE_INITIALIZER;
 
-void GatherMetricsForRenderProcess(content::RenderProcessHost* host,
-                                   ProcessMetricsMetadata* data) {
+void GatherMetricsForRenderProcess(
+    content::RenderProcessHost* host,
+    const std::vector<content::RenderWidgetHost*>& widgets,
+    ProcessMetricsMetadata* data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  for (auto* widget : widgets) {
+    DCHECK_EQ(host, widget->GetProcess());
+
+    content::RenderWidgetHostView* rwhv = widget->GetView();
+    if (rwhv && rwhv->IsRenderWidgetHostViewChildFrame()) {
+      data->contains_oopif = true;
+      break;
+    }
+  }
+
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   content::BrowserContext* browser_context = host->GetBrowserContext();
   extensions::ProcessMap* extension_process_map =
       extensions::ProcessMap::Get(browser_context);
 
   std::set<std::string> extension_ids =
       extension_process_map->GetExtensionsInProcess(host->GetID());
 
   // We only collect more granular metrics when there's only one extension
   // running in a given renderer, to reduce noise.
@@ skipping 35 matching lines @@
 }
 
 void PerformanceMonitor::GatherMetricsMapOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   static int current_update_sequence = 0;
   // Even in the "somewhat" unlikely event this wraps around,
   // it doesn't matter. We just check it for inequality.
   current_update_sequence++;
 
+  // First pass, collate the widgets by process ID.
+  std::map<content::RenderProcessHost*, std::vector<content::RenderWidgetHost*>>
+      widgets_by_rph;
+  std::unique_ptr<content::RenderWidgetHostIterator> widget_it(
+      content::RenderWidgetHost::GetRenderWidgetHosts());
+  while (content::RenderWidgetHost* widget = widget_it->GetNextHost()) {
+    // Ignore processes that don't have a connection, such as crashed tabs.
+    if (!widget->GetProcess()->HasConnection())
+      continue;
+    widgets_by_rph[widget->GetProcess()].push_back(widget);
+  }
+
   // Find all render child processes; has to be done on the UI thread.
   for (content::RenderProcessHost::iterator rph_iter =
            content::RenderProcessHost::AllHostsIterator();
        !rph_iter.IsAtEnd(); rph_iter.Advance()) {
     content::RenderProcessHost* host = rph_iter.GetCurrentValue();
     ProcessMetricsMetadata data;
     data.process_type = content::PROCESS_TYPE_RENDERER;
     data.handle = host->GetHandle();
 
-    GatherMetricsForRenderProcess(host, &data);
+    GatherMetricsForRenderProcess(host, widgets_by_rph[host], &data);
     MarkProcessAsAlive(data, current_update_sequence);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PerformanceMonitor::GatherMetricsMapOnIOThread,
                  base::Unretained(this), current_update_sequence));
 }
 
 void PerformanceMonitor::MarkProcessAsAlive(
@@ skipping 89 matching lines @@
 
 void PerformanceMonitor::RunTriggersUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (auto& metrics : metrics_map_)
     metrics.second->RunPerformanceTriggers();
 
   StartGatherCycle();
 }
 
 }  // namespace performance_monitor