fix about:memory and memory histograms to show extensions more clearly

chrome/browser/memory_details.cc

 // Copyright (c) 2010 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/memory_details.h"
 
 #include "app/l10n_util.h"
 #include "base/file_version_info.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_child_process_host.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/renderer_host/backing_store_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/common/bindings_policy.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 #if defined(OS_LINUX)
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 ProcessMemoryInformation::ProcessMemoryInformation()
     : pid(0),
       num_processes(0),
       is_diagnostics(false),
-      type(ChildProcessInfo::UNKNOWN_PROCESS) {
+      type(ChildProcessInfo::UNKNOWN_PROCESS),
+      renderer_type(ChildProcessInfo::RENDERER_UNKNOWN) {
 }
 
 ProcessMemoryInformation::~ProcessMemoryInformation() {}
 
 ProcessData::ProcessData() {}
 
 ProcessData::ProcessData(const ProcessData& rhs)
     : name(rhs.name),
       process_name(rhs.process_name),
       processes(rhs.processes) {
@@ skipping 39 matching lines @@
   std::vector<ProcessMemoryInformation> child_info;
 
   // Collect the list of child processes.
   for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
     ProcessMemoryInformation info;
     info.pid = base::GetProcId(iter->handle());
     if (!info.pid)
       continue;
 
     info.type = iter->type();
+    info.renderer_type = iter->renderer_type();
     info.titles.push_back(WideToUTF16Hack(iter->name()));
     child_info.push_back(info);
   }
 
   // Now go do expensive memory lookups from the file thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &MemoryDetails::CollectProcessData, child_info));
 }
 
 void MemoryDetails::CollectChildInfoOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
 #if defined(OS_LINUX)
   const pid_t zygote_pid = ZygoteHost::GetInstance()->pid();
   const pid_t sandbox_helper_pid = RenderSandboxHostLinux::GetInstance()->pid();
 #endif
 
   ProcessData* const chrome_browser = ChromeBrowser();
   // Get more information about the process.
   for (size_t index = 0; index < chrome_browser->processes.size();
       index++) {
     // Check if it's a renderer, if so get the list of page titles in it and
-    // check if it's a diagnostics-related process.  We skip all diagnostics
-    // pages (e.g. "about:xxx" URLs).  Iterate the RenderProcessHosts to find
-    // the tab contents.
+    // check if it's a diagnostics-related process.  We skip about:memory pages.
+    // Iterate the RenderProcessHosts to find the tab contents.
     ProcessMemoryInformation& process =
         chrome_browser->processes[index];
 
     for (RenderProcessHost::iterator renderer_iter(
          RenderProcessHost::AllHostsIterator()); !renderer_iter.IsAtEnd();
          renderer_iter.Advance()) {
-      DCHECK(renderer_iter.GetCurrentValue());
+      RenderProcessHost* rph = renderer_iter.GetCurrentValue();
+      DCHECK(rph);
       // Ignore processes that don't have a connection, such as crashed tabs.
-      if (!renderer_iter.GetCurrentValue()->HasConnection() || process.pid !=
-              base::GetProcId(renderer_iter.GetCurrentValue()->GetHandle())) {
+      if (!rph->HasConnection() ||
+          process.pid != base::GetProcId(rph->GetHandle())) {
         continue;
       }
       process.type = ChildProcessInfo::RENDER_PROCESS;
       // The RenderProcessHost may host multiple TabContents.  Any
       // of them which contain diagnostics information make the whole
       // process be considered a diagnostics process.
       //
       // NOTE: This is a bit dangerous.  We know that for now, listeners
       //       are always RenderWidgetHosts.  But in theory, they don't
       //       have to be.
-      RenderProcessHost::listeners_iterator iter(
-          renderer_iter.GetCurrentValue()->ListenersIterator());
+      RenderProcessHost::listeners_iterator iter(rph->ListenersIterator());
       for (; !iter.IsAtEnd(); iter.Advance()) {
         const RenderWidgetHost* widget =
             static_cast<const RenderWidgetHost*>(iter.GetCurrentValue());
         DCHECK(widget);
         if (!widget || !widget->IsRenderView())
           continue;
 
         const RenderViewHost* host = static_cast<const RenderViewHost*>(widget);
+        RenderViewHostDelegate* host_delegate = host->delegate();
+        GURL url = host_delegate->GetURL();
+        ViewType::Type type = host_delegate->GetRenderViewType();
+        if (host->enabled_bindings() & BindingsPolicy::DOM_UI) {
+          // TODO(erikkay) the type for devtools doesn't actually appear to
+          // be set.
+          if (type == ViewType::DEV_TOOLS_UI)
+            process.renderer_type = ChildProcessInfo::RENDERER_DEVTOOLS;
+          else
+            process.renderer_type = ChildProcessInfo::RENDERER_CHROME;
+        } else if (host->enabled_bindings() & BindingsPolicy::EXTENSION) {
+          process.renderer_type = ChildProcessInfo::RENDERER_EXTENSION;
+        }
         TabContents* contents = NULL;
-        if (host->delegate())
-          contents = host->delegate()->GetAsTabContents();
-        if (!contents)
+        if (host_delegate)
+          contents = host_delegate->GetAsTabContents();
+        if (!contents) {
+          if (host->is_extension_process()) {
+            // TODO(erikkay) should we just add GetAsExtensionHost to
+            // TabContents?
+            ExtensionHost* eh = static_cast<ExtensionHost*>(host_delegate);
+            string16 title = UTF8ToUTF16(eh->extension()->name());
+            process.titles.push_back(title);
+          } else if (process.renderer_type ==
+                     ChildProcessInfo::RENDERER_UNKNOWN) {
+            switch (type) {
+              case ViewType::BACKGROUND_CONTENTS:
+                process.renderer_type =
+                    ChildProcessInfo::RENDERER_BACKGROUND_APP;
+                break;
+              case ViewType::INTERSTITIAL_PAGE:
+                process.renderer_type = ChildProcessInfo::RENDERER_INTERSTITIAL;
+                process.titles.push_back(UTF8ToUTF16(url.spec()));
+                break;
+              case ViewType::NOTIFICATION:
+                process.renderer_type = ChildProcessInfo::RENDERER_NOTIFICATION;
+                break;
+              default:
+                process.renderer_type = ChildProcessInfo::RENDERER_UNKNOWN;
+                break;
+            }
+          }
           continue;
+        }
+
+        if (process.renderer_type == ChildProcessInfo::RENDERER_UNKNOWN)

[asargent_no_longer_on_chrome, 2010/12/25 05:20:12]

It's not obvious why you're converting unknown renderer types to normal here.
I'm guessing that's just because for display purposes we'd rather show newly
added types (that someone has forgotten to update this code to handle) than hide
them? Maybe add a comment about this.

[Erik does not do reviews, 2010/12/28 16:59:18]

I added a comment.

+          process.renderer_type = ChildProcessInfo::RENDERER_NORMAL;
+
         string16 title = contents->GetTitle();
         if (!title.length())
           title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
         process.titles.push_back(title);
 
         // We need to check the pending entry as well as the virtual_url to
         // see if it's an about:memory URL (we don't want to count these in the
         // total memory usage of the browser).
         //
         // When we reach here, about:memory will be the pending entry since we
@@ skipping 41 matching lines @@
 
   OnDetailsAvailable();
 }
 
 void MemoryDetails::UpdateHistograms() {
   // Reports a set of memory metrics to UMA.
   // Memory is measured in KB.
 
   const ProcessData& browser = *ChromeBrowser();
   size_t aggregate_memory = 0;
+  int chrome_count = 0;
+  int extension_count = 0;
   int plugin_count = 0;
+  int renderer_count = 0;
+  int other_count = 0;
   int worker_count = 0;
   for (size_t index = 0; index < browser.processes.size(); index++) {
     int sample = static_cast<int>(browser.processes[index].working_set.priv);
     aggregate_memory += sample;
     switch (browser.processes[index].type) {
       case ChildProcessInfo::BROWSER_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
         break;
-      case ChildProcessInfo::RENDER_PROCESS:
-        UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer", sample);
+      case ChildProcessInfo::RENDER_PROCESS: {
+        ChildProcessInfo::RendererProcessType renderer_type =
+            browser.processes[index].renderer_type;
+        switch (renderer_type) {
+          case ChildProcessInfo::RENDERER_EXTENSION:
+            UMA_HISTOGRAM_MEMORY_KB("Memory.Extension", sample);
+            extension_count++;
+            break;
+          case ChildProcessInfo::RENDERER_CHROME:
+            UMA_HISTOGRAM_MEMORY_KB("Memory.Chrome", sample);
+            chrome_count++;
+            break;
+          case ChildProcessInfo::RENDERER_NORMAL:
+          default:
+            // TODO(erikkay): Should we bother splitting out the other subtypes?
+            UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer", sample);
+            renderer_count++;
+            break;
+        }
         break;
+      }
       case ChildProcessInfo::PLUGIN_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Plugin", sample);
         plugin_count++;
         break;
       case ChildProcessInfo::WORKER_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Worker", sample);
         worker_count++;
         break;
       case ChildProcessInfo::UTILITY_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Utility", sample);
+        other_count++;
         break;
       case ChildProcessInfo::ZYGOTE_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Zygote", sample);
+        other_count++;
         break;
       case ChildProcessInfo::SANDBOX_HELPER_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.SandboxHelper", sample);
+        other_count++;
         break;
       case ChildProcessInfo::NACL_LOADER_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
+        other_count++;
         break;
       case ChildProcessInfo::NACL_BROKER_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
+        other_count++;
         break;
       case ChildProcessInfo::GPU_PROCESS:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Gpu", sample);
+        other_count++;
         break;
       default:
         NOTREACHED();
     }
   }
   UMA_HISTOGRAM_MEMORY_KB("Memory.BackingStore",
                           BackingStoreManager::MemorySize() / 1024);
 
   UMA_HISTOGRAM_COUNTS_100("Memory.ProcessCount",
       static_cast<int>(browser.processes.size()));
+  UMA_HISTOGRAM_COUNTS_100("Memory.ChromeProcessCount", chrome_count);
+  UMA_HISTOGRAM_COUNTS_100("Memory.ExtensionProcessCount", extension_count);
+  UMA_HISTOGRAM_COUNTS_100("Memory.OtherProcessCount", other_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.PluginProcessCount", plugin_count);
+  UMA_HISTOGRAM_COUNTS_100("Memory.RendererProcessCount", renderer_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
   // TODO(viettrungluu): Do we want separate counts for the other
   // (platform-specific) process types?
 
   int total_sample = static_cast<int>(aggregate_memory / 1000);
   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
 }