Move the ProcessType enum out to its own file. This is in preparation for getting rid of ChildPro...

chrome/browser/memory_details.cc

 // Copyright (c) 2011 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 "base/bind.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/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_view_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_child_process_host.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/child_process_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/bindings_policy.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include "content/browser/renderer_host/render_sandbox_host_linux.h"
 #include "content/browser/zygote_host_linux.h"
@@ skipping 21 matching lines @@
       return "Background App";
     case RENDERER_UNKNOWN:
     default:
       NOTREACHED() << "Unknown renderer process type!";
       return "Unknown";
   }
 }
 
 // static
 std::string ProcessMemoryInformation::GetFullTypeNameInEnglish(
-    ChildProcessInfo::ProcessType type,
+    content::ProcessType type,
     RendererProcessType rtype) {
-  if (type == ChildProcessInfo::RENDER_PROCESS)
+  if (type == content::PROCESS_TYPE_RENDERER)
     return GetRendererTypeNameInEnglish(rtype);
   return ChildProcessInfo::GetTypeNameInEnglish(type);
 }
 
 ProcessMemoryInformation::ProcessMemoryInformation()
     : pid(0),
       num_processes(0),
       is_diagnostics(false),
-      type(ChildProcessInfo::UNKNOWN_PROCESS),
+      type(content::PROCESS_TYPE_UNKNOWN),
       renderer_type(RENDERER_UNKNOWN) {
 }
 
 ProcessMemoryInformation::~ProcessMemoryInformation() {}
 
 ProcessData::ProcessData() {}
 
 ProcessData::ProcessData(const ProcessData& rhs)
     : name(rhs.name),
       process_name(rhs.process_name),
@@ skipping 81 matching lines @@
             content::RenderProcessHost::AllHostsIterator());
          !renderer_iter.IsAtEnd(); renderer_iter.Advance()) {
       content::RenderProcessHost* render_process_host =
           renderer_iter.GetCurrentValue();
       DCHECK(render_process_host);
       // Ignore processes that don't have a connection, such as crashed tabs.
       if (!render_process_host->HasConnection() ||
           process.pid != base::GetProcId(render_process_host->GetHandle())) {
         continue;
       }
-      process.type = ChildProcessInfo::RENDER_PROCESS;
+      process.type = content::PROCESS_TYPE_RENDERER;
       Profile* profile =
           Profile::FromBrowserContext(
               render_process_host->GetBrowserContext());
       ExtensionService* extension_service = profile->GetExtensionService();
       extensions::ProcessMap* extension_process_map =
           extension_service->process_map();
 
       // The RenderProcessHost may host multiple TabContents.  Any
       // of them which contain diagnostics information make the whole
       // process be considered a diagnostics process.
@@ skipping 103 matching lines @@
                                   chrome::kChromeUIMemoryURL)) ||
             (pending_entry &&
              LowerCaseEqualsASCII(pending_entry->virtual_url().spec(),
                                   chrome::kChromeUIMemoryURL)))
           process.is_diagnostics = true;
       }
     }
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     if (process.pid == zygote_pid) {
-      process.type = ChildProcessInfo::ZYGOTE_PROCESS;
+      process.type = content::PROCESS_TYPE_ZYGOTE;
     } else if (process.pid == sandbox_helper_pid) {
-      process.type = ChildProcessInfo::SANDBOX_HELPER_PROCESS;
+      process.type = content::PROCESS_TYPE_SANDBOX_HELPER;
     }
 #endif
   }
 
   // Get rid of other Chrome processes that are from a different profile.
   for (size_t index = 0; index < chrome_browser->processes.size();
       index++) {
     if (chrome_browser->processes[index].type ==
-        ChildProcessInfo::UNKNOWN_PROCESS) {
+        content::PROCESS_TYPE_UNKNOWN) {
       chrome_browser->processes.erase(
           chrome_browser->processes.begin() + index);
       index--;
     }
   }
 
   UpdateHistograms();
 
   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 pepper_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:
+      case content::PROCESS_TYPE_BROWSER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
         break;
-      case ChildProcessInfo::RENDER_PROCESS: {
+      case content::PROCESS_TYPE_RENDERER: {
         ProcessMemoryInformation::RendererProcessType renderer_type =
             browser.processes[index].renderer_type;
         switch (renderer_type) {
           case ProcessMemoryInformation::RENDERER_EXTENSION:
             UMA_HISTOGRAM_MEMORY_KB("Memory.Extension", sample);
             extension_count++;
             break;
           case ProcessMemoryInformation::RENDERER_CHROME:
             UMA_HISTOGRAM_MEMORY_KB("Memory.Chrome", sample);
             chrome_count++;
             break;
           case ProcessMemoryInformation::RENDERER_UNKNOWN:
             NOTREACHED() << "Unknown renderer process type.";
             break;
           case ProcessMemoryInformation::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:
+      case content::PROCESS_TYPE_PLUGIN:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Plugin", sample);
         plugin_count++;
         break;
-      case ChildProcessInfo::WORKER_PROCESS:
+      case content::PROCESS_TYPE_WORKER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Worker", sample);
         worker_count++;
         break;
-      case ChildProcessInfo::UTILITY_PROCESS:
+      case content::PROCESS_TYPE_UTILITY:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Utility", sample);
         other_count++;
         break;
-      case ChildProcessInfo::ZYGOTE_PROCESS:
+      case content::PROCESS_TYPE_ZYGOTE:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Zygote", sample);
         other_count++;
         break;
-      case ChildProcessInfo::SANDBOX_HELPER_PROCESS:
+      case content::PROCESS_TYPE_SANDBOX_HELPER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.SandboxHelper", sample);
         other_count++;
         break;
-      case ChildProcessInfo::NACL_LOADER_PROCESS:
+      case content::PROCESS_TYPE_NACL_LOADER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
         other_count++;
         break;
-      case ChildProcessInfo::NACL_BROKER_PROCESS:
+      case content::PROCESS_TYPE_NACL_BROKER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
         other_count++;
         break;
-      case ChildProcessInfo::GPU_PROCESS:
+      case content::PROCESS_TYPE_GPU:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Gpu", sample);
         other_count++;
         break;
-      case ChildProcessInfo::PPAPI_PLUGIN_PROCESS:
+      case content::PROCESS_TYPE_PPAPI_PLUGIN:
         UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPlugin", sample);
         pepper_plugin_count++;
         break;
       default:
         NOTREACHED();
         break;
     }
   }
   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.PepperPluginProcessCount",
       pepper_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);
 }