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

chrome/browser/task_manager/task_manager_resource_providers.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/task_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 29 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_child_process_host.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/common/process_type.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
 #include "skia/ext/skia_utils_mac.h"
@@ skipping 719 matching lines @@
 }
 
 base::ProcessHandle TaskManagerChildProcessResource::GetProcess() const {
   return child_process_.handle();
 }
 
 TaskManager::Resource::Type TaskManagerChildProcessResource::GetType() const {
   // Translate types to TaskManager::ResourceType, since ChildProcessInfo's type
   // is not available for all TaskManager resources.
   switch (child_process_.type()) {
-    case ChildProcessInfo::PLUGIN_PROCESS:
-    case ChildProcessInfo::PPAPI_PLUGIN_PROCESS:
-    case ChildProcessInfo::PPAPI_BROKER_PROCESS:
+    case content::PROCESS_TYPE_PLUGIN:
+    case content::PROCESS_TYPE_PPAPI_PLUGIN:
+    case content::PROCESS_TYPE_PPAPI_BROKER:
       return TaskManager::Resource::PLUGIN;
-    case ChildProcessInfo::NACL_LOADER_PROCESS:
-    case ChildProcessInfo::NACL_BROKER_PROCESS:
+    case content::PROCESS_TYPE_NACL_LOADER:
+    case content::PROCESS_TYPE_NACL_BROKER:
       return TaskManager::Resource::NACL;
-    case ChildProcessInfo::UTILITY_PROCESS:
+    case content::PROCESS_TYPE_UTILITY:
       return TaskManager::Resource::UTILITY;
-    case ChildProcessInfo::PROFILE_IMPORT_PROCESS:
+    case content::PROCESS_TYPE_PROFILE_IMPORT:
       return TaskManager::Resource::PROFILE_IMPORT;
-    case ChildProcessInfo::ZYGOTE_PROCESS:
+    case content::PROCESS_TYPE_ZYGOTE:
       return TaskManager::Resource::ZYGOTE;
-    case ChildProcessInfo::SANDBOX_HELPER_PROCESS:
+    case content::PROCESS_TYPE_SANDBOX_HELPER:
       return TaskManager::Resource::SANDBOX_HELPER;
-    case ChildProcessInfo::GPU_PROCESS:
+    case content::PROCESS_TYPE_GPU:
       return TaskManager::Resource::GPU;
     default:
       return TaskManager::Resource::UNKNOWN;
   }
 }
 
 bool TaskManagerChildProcessResource::SupportNetworkUsage() const {
   return network_usage_support_;
 }
 
 void TaskManagerChildProcessResource::SetSupportNetworkUsage() {
   network_usage_support_ = true;
 }
 
 string16 TaskManagerChildProcessResource::GetLocalizedTitle() const {
   string16 title = child_process_.name();
   if (title.empty()) {
     switch (child_process_.type()) {
-      case ChildProcessInfo::PLUGIN_PROCESS:
-      case ChildProcessInfo::PPAPI_PLUGIN_PROCESS:
-      case ChildProcessInfo::PPAPI_BROKER_PROCESS:
+      case content::PROCESS_TYPE_PLUGIN:
+      case content::PROCESS_TYPE_PPAPI_PLUGIN:
+      case content::PROCESS_TYPE_PPAPI_BROKER:
         title = l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UNKNOWN_PLUGIN_NAME);
         break;
       default:
         // Nothing to do for non-plugin processes.
         break;
     }
   }
 
   // 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);
 
   switch (child_process_.type()) {
-    case ChildProcessInfo::UTILITY_PROCESS:
+    case content::PROCESS_TYPE_UTILITY:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UTILITY_PREFIX);
 
-    case ChildProcessInfo::PROFILE_IMPORT_PROCESS:
+    case content::PROCESS_TYPE_PROFILE_IMPORT:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_UTILITY_PREFIX);
 
-    case ChildProcessInfo::GPU_PROCESS:
+    case content::PROCESS_TYPE_GPU:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_GPU_PREFIX);
 
-    case ChildProcessInfo::NACL_BROKER_PROCESS:
+    case content::PROCESS_TYPE_NACL_BROKER:
       return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NACL_BROKER_PREFIX);
 
-    case ChildProcessInfo::PLUGIN_PROCESS:
-    case ChildProcessInfo::PPAPI_PLUGIN_PROCESS:
+    case content::PROCESS_TYPE_PLUGIN:
+    case content::PROCESS_TYPE_PPAPI_PLUGIN:
       return l10n_util::GetStringFUTF16(
           IDS_TASK_MANAGER_PLUGIN_PREFIX, title, child_process_.version());
 
-    case ChildProcessInfo::PPAPI_BROKER_PROCESS:
+    case content::PROCESS_TYPE_PPAPI_BROKER:
       return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PLUGIN_BROKER_PREFIX,
                                         title, child_process_.version());
 
-    case ChildProcessInfo::NACL_LOADER_PROCESS:
+    case content::PROCESS_TYPE_NACL_LOADER:
       return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_NACL_PREFIX, title);
 
     // These types don't need display names or get them from elsewhere.
-    case ChildProcessInfo::BROWSER_PROCESS:
-    case ChildProcessInfo::RENDER_PROCESS:
-    case ChildProcessInfo::ZYGOTE_PROCESS:
-    case ChildProcessInfo::SANDBOX_HELPER_PROCESS:
-    case ChildProcessInfo::MAX_PROCESS:
+    case content::PROCESS_TYPE_BROWSER:
+    case content::PROCESS_TYPE_RENDERER:
+    case content::PROCESS_TYPE_ZYGOTE:
+    case content::PROCESS_TYPE_SANDBOX_HELPER:
+    case content::PROCESS_TYPE_MAX:
       NOTREACHED();
       break;
 
-    case ChildProcessInfo::WORKER_PROCESS:
+    case content::PROCESS_TYPE_WORKER:
       NOTREACHED() << "Workers are not handled by this provider.";
       break;
 
-    case ChildProcessInfo::UNKNOWN_PROCESS:
+    case content::PROCESS_TYPE_UNKNOWN:
       NOTREACHED() << "Need localized name for child process type.";
   }
 
   return title;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 73 matching lines @@
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 void TaskManagerChildProcessResourceProvider::Add(
     const ChildProcessInfo& child_process_info) {
   if (!updating_)
     return;
   // Workers are handled by TaskManagerWorkerResourceProvider.
-  if (child_process_info.type() == ChildProcessInfo::WORKER_PROCESS)
+  if (child_process_info.type() == content::PROCESS_TYPE_WORKER)
     return;
   std::map<ChildProcessInfo, TaskManagerChildProcessResource*>::
       const_iterator iter = resources_.find(child_process_info);
   if (iter != resources_.end()) {
     // The case may happen that we have added a child_process_info as part of
     // the iteration performed during StartUpdating() call but the notification
     // that it has connected was not fired yet. So when the notification
     // happens, we already know about this plugin and just ignore it.
     return;
   }
   AddToTaskManager(child_process_info);
 }
 
 void TaskManagerChildProcessResourceProvider::Remove(
     const ChildProcessInfo& child_process_info) {
   if (!updating_)
     return;
-  if (child_process_info.type() == ChildProcessInfo::WORKER_PROCESS)
+  if (child_process_info.type() == content::PROCESS_TYPE_WORKER)
     return;
   std::map<ChildProcessInfo, TaskManagerChildProcessResource*>
       ::iterator iter = resources_.find(child_process_info);
   if (iter == resources_.end()) {
     // ChildProcessInfo disconnection notifications are asynchronous, so we
     // might be notified for a plugin we don't know anything about (if it was
     // closed before the task manager was shown and destroyed after that).
     return;
   }
   // Remove the resource from the Task Manager.
@@ skipping 390 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }