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

chrome/common/child_process_info.h

 // 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.
 
 #ifndef CHROME_COMMON_CHILD_PROCESS_INFO_H_
 #define CHROME_COMMON_CHILD_PROCESS_INFO_H_
 #pragma once
 
 #include <string>
 
@@ skipping 14 matching lines @@
     NACL_LOADER_PROCESS,
     UTILITY_PROCESS,
     PROFILE_IMPORT_PROCESS,
     ZYGOTE_PROCESS,
     SANDBOX_HELPER_PROCESS,
     NACL_BROKER_PROCESS,
     GPU_PROCESS,
     PPAPI_PLUGIN_PROCESS
   };
 
+  // NOTE: Do not remove or reorder the elements in this enum, and only add new

[asargent_no_longer_on_chrome, 2010/12/23 21:32:41]

Consider adding a unit test that depends on the expected literal values to catch
violators. 

[Erik does not do reviews, 2010/12/24 00:52:11]

To document our offline conversation:
I agree in principle, but in practice, there are a bunch of these throughout the
codebase and we should come up with a way of expressing "invariant enums" in
such a way that an automated unittest could catch bad changes to any of them. 
We brainstormed an idea for how to do this (a script that generates output based
on these enums, but won't update it incompatibly, and a unit test that compares
verifies that the script has been run), but agreed that this could be punted.

+  // items at the end. We depend on these specific values in a histogram.
+  // TODO(erikkay) - other possibilities to include background contents,
+  // interstitials, ChromeOS UI, devtools, etc.
+  enum RendererProcessType {
+    RENDERER_UNKNOWN = 0,
+    RENDERER_NORMAL,
+    RENDERER_CHROME,
+    RENDERER_EXTENSION
+  };
+
   ChildProcessInfo(const ChildProcessInfo& original);
   virtual ~ChildProcessInfo();
 
   ChildProcessInfo& operator=(const ChildProcessInfo& original);
 
   // Returns the type of the process.
   ProcessType type() const { return type_; }
+  RendererProcessType renderer_type() const { return renderer_type_; }
 
   // Returns the name of the process.  i.e. for plugins it might be Flash, while
   // for workers it might be the domain that it's from.
   std::wstring name() const { return name_; }
 
   // Returns the version of the exe, this only appliest to plugins. Otherwise
   // the string is empty.
   std::wstring version() const { return version_; }
 
   // Getter to the process handle.
   base::ProcessHandle handle() const { return process_.handle(); }
 
   // The unique identifier for this child process. This identifier is NOT a
   // process ID, and will be unique for all types of child process for
   // one run of the browser.
   int id() const { return id_; }
 
   void SetProcessBackgrounded() const { process_.SetProcessBackgrounded(true); }
 
   // Returns an English name of the process type, should only be used for non
   // user-visible strings, or debugging pages like about:memory.
+  static std::string GetFullTypeNameInEnglish(ProcessType type,
+                                              RendererProcessType rtype);
   static std::string GetTypeNameInEnglish(ProcessType type);
+  static std::string GetRendererTypeNameInEnglish(RendererProcessType type);
 
   // Returns a localized title for the child process.  For example, a plugin
   // process would be "Plug-in: Flash" when name is "Flash".
   string16 GetLocalizedTitle() const;
 
   // We define the < operator so that the ChildProcessInfo can be used as a key
   // in a std::map.
   bool operator <(const ChildProcessInfo& rhs) const {
     if (process_.handle() != rhs.process_.handle())
       return process_ .handle() < rhs.process_.handle();
@@ skipping 18 matching lines @@
   static int GenerateChildProcessUniqueId();
 
  protected:
   // Derived objects need to use this constructor so we know what type we are.
   // If the caller has already generated a unique ID for this child process,
   // it should pass it as the second argument. Otherwise, -1 should be passed
   // and a unique ID will be automatically generated.
   ChildProcessInfo(ProcessType type, int id);
 
   void set_type(ProcessType type) { type_ = type; }
+  void set_renderer_type(RendererProcessType type) { renderer_type_ = type; }
   void set_name(const std::wstring& name) { name_ = name; }
   void set_version(const std::wstring& ver) { version_ = ver; }
   void set_handle(base::ProcessHandle handle) { process_.set_handle(handle); }
 
  private:
   ProcessType type_;
+  RendererProcessType renderer_type_;
   std::wstring name_;
   std::wstring version_;
   int id_;
 
   // The handle to the process.
   mutable base::Process process_;
 };
 
 #endif  // CHROME_COMMON_CHILD_PROCESS_INFO_H_