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* render_process_host = renderer_iter.GetCurrentValue();
+      DCHECK(render_process_host);
       // 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 (!render_process_host->HasConnection() ||
+          process.pid != base::GetProcId(render_process_host->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());
+          render_process_host->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;
+        }
+
+        // Since We have a TabContents and and the renderer type hasn't been
+        // set yet, it must be a normal tabbed renderer.
+        if (process.renderer_type == ChildProcessInfo::RENDERER_UNKNOWN)
+          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_UNKNOWN:
+            NOTREACHED() << "Unknown renderer process type.";
+            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);
 }