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

chrome/common/child_process_info.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/common/child_process_info.h"
 
 #include <limits>
 
 #include "app/l10n_util.h"
 #include "base/atomicops.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "grit/generated_resources.h"
 
 ChildProcessInfo::ChildProcessInfo(const ChildProcessInfo& original)
     : type_(original.type_),
+      renderer_type_(original.renderer_type_),
       name_(original.name_),
       version_(original.version_),
       id_(original.id_),
       process_(original.process_) {
 }
 
 ChildProcessInfo::~ChildProcessInfo() {
 }
 
 ChildProcessInfo& ChildProcessInfo::operator=(
     const ChildProcessInfo& original) {
   if (&original != this) {
     type_ = original.type_;
+    renderer_type_ = original.renderer_type_;
     name_ = original.name_;
     version_ = original.version_;
     id_ = original.id_;
     process_ = original.process_;
   }
   return *this;
 }
 
+// static
 std::string ChildProcessInfo::GetTypeNameInEnglish(
     ChildProcessInfo::ProcessType type) {
   switch (type) {
     case BROWSER_PROCESS:
       return "Browser";
     case RENDER_PROCESS:
       return "Tab";
     case PLUGIN_PROCESS:
       return "Plug-in";
     case WORKER_PROCESS:
@@ skipping 14 matching lines @@
       return "GPU";
     case PPAPI_PLUGIN_PROCESS:
       return "Pepper Plugin";
     case UNKNOWN_PROCESS:
     default:
       DCHECK(false) << "Unknown child process type!";
       return "Unknown";
   }
 }
 
+// static
+std::string ChildProcessInfo::GetRendererTypeNameInEnglish(
+    ChildProcessInfo::RendererProcessType type) {
+  switch (type) {
+    case RENDERER_NORMAL:
+      return "Tab";
+    case RENDERER_CHROME:
+      return "Tab (Chrome)";
+    case RENDERER_EXTENSION:
+      return "Extension";
+    case RENDERER_UNKNOWN:
+    default:
+      NOTREACHED() << "Unknown renderer process type!";
+      return "Unknown";
+  }
+}
+
+// static
+std::string ChildProcessInfo::GetFullTypeNameInEnglish(
+    ChildProcessInfo::ProcessType type,
+    ChildProcessInfo::RendererProcessType rtype) {
+  if (type == RENDER_PROCESS)
+    return GetRendererTypeNameInEnglish(rtype);
+  return GetTypeNameInEnglish(type);
+}
+
+
 string16 ChildProcessInfo::GetLocalizedTitle() const {
   string16 title = WideToUTF16Hack(name_);
   if (type_ == ChildProcessInfo::PLUGIN_PROCESS && title.empty())
     title = l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UNKNOWN_PLUGIN_NAME);
 
   // Explicitly mark name as LTR if there is no strong RTL character,
   // to avoid the wrong concatenation result similar to "!Yahoo! Mail: the
   // best web-based Email: NIGULP", in which "NIGULP" stands for the Hebrew
   // or Arabic word for "plugin".
   base::i18n::AdjustStringForLocaleDirection(&title);
@@ skipping 32 matching lines @@
       break;
 
     case UNKNOWN_PROCESS:
       NOTREACHED() << "Need localized name for child process type.";
   }
 
   return title;
 }
 
 ChildProcessInfo::ChildProcessInfo(ProcessType type, int id) : type_(type) {
+  renderer_type_ = RENDERER_UNKNOWN;

[Mike Belshe, 2010/12/24 00:50:53]

Is it expected that type_ != RENDER_PROCESS if we are here?  Could we dcheck
that?

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

This is the constructor, so it's expected to be uninitialized.  I moved the
declaration to a more reasonable place and changed the assignment to be an
initializer.

   if (id == -1)
     id_ = GenerateChildProcessUniqueId();
   else
     id_ = id;
 }
 
 std::string ChildProcessInfo::GenerateRandomChannelID(void* instance) {
   // Note: the string must start with the current process id, this is how
   // child processes determine the pid of the parent.
   // Build the channel ID.  This is composed of a unique identifier for the
   // parent browser process, an identifier for the child instance, and a random
   // component. We use a random component so that a hacked child process can't
   // cause denial of service by causing future named pipe creation to fail.
   return base::StringPrintf("%d.%p.%d",
                             base::GetCurrentProcId(), instance,
                             base::RandInt(0, std::numeric_limits<int>::max()));
 }
 
 // static
 int ChildProcessInfo::GenerateChildProcessUniqueId() {
   // This function must be threadsafe.
   static base::subtle::Atomic32 last_unique_child_id = 0;
   return base::subtle::NoBarrier_AtomicIncrement(&last_unique_child_id, 1);
 }