Split the ProcessType enum into process types that content knows about (which will remain in src\co…

chrome/browser/memory_details.cc

 // Copyright (c) 2012 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/stringprintf.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/browser/view_type_utils.h"
+#include "chrome/common/chrome_process_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/bindings_policy.h"
-#include "content/public/common/process_type.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) && !defined(OS_ANDROID)
 #include "content/public/browser/zygote_host_linux.h"
 #endif
 
 using base::StringPrintf;
 using content::BrowserChildProcessHostIterator;
@@ skipping 24 matching lines @@
       return "Background App";
     case RENDERER_UNKNOWN:
     default:
       NOTREACHED() << "Unknown renderer process type!";
       return "Unknown";
   }
 }
 
 // static
 std::string ProcessMemoryInformation::GetFullTypeNameInEnglish(
-    content::ProcessType type,
+    int process_type,
     RendererProcessType rtype) {
-  if (type == content::PROCESS_TYPE_RENDERER)
+  if (process_type == content::PROCESS_TYPE_RENDERER)
     return GetRendererTypeNameInEnglish(rtype);
-  return content::GetProcessTypeNameInEnglish(type);
+  return content::GetProcessTypeNameInEnglish(process_type);
 }
 
 ProcessMemoryInformation::ProcessMemoryInformation()
     : pid(0),
       num_processes(0),
       is_diagnostics(false),
-      type(content::PROCESS_TYPE_UNKNOWN),
+      process_type(content::PROCESS_TYPE_UNKNOWN),
       renderer_type(RENDERER_UNKNOWN) {
 }
 
 ProcessMemoryInformation::~ProcessMemoryInformation() {}
 
 bool ProcessMemoryInformation::operator<(
     const ProcessMemoryInformation& rhs) const {
   return working_set.priv < rhs.working_set.priv;
 }
 
@@ skipping 46 matching lines @@
   log.reserve(4096);
   ProcessMemoryInformationList processes = ChromeBrowser()->processes;
   // Sort by memory consumption, low to high.
   std::sort(processes.begin(), processes.end());
   // Print from high to low.
   for (ProcessMemoryInformationList::reverse_iterator iter1 =
           processes.rbegin();
        iter1 != processes.rend();
        ++iter1) {
     log += ProcessMemoryInformation::GetFullTypeNameInEnglish(
-            iter1->type, iter1->renderer_type);
+            iter1->process_type, iter1->renderer_type);
     if (!iter1->titles.empty()) {
       log += " [";
       for (std::vector<string16>::const_iterator iter2 =
                iter1->titles.begin();
            iter2 != iter1->titles.end(); ++iter2) {
         if (iter2 != iter1->titles.begin())
           log += "|";
         log += UTF16ToUTF8(*iter2);
       }
       log += "]";
@@ skipping 13 matching lines @@
   // Collect the list of child processes. A 0 |handle| means that
   // the process is being launched, so we skip it.
   for (BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
     ProcessMemoryInformation info;
     if (!iter.GetData().handle)
       continue;
     info.pid = base::GetProcId(iter.GetData().handle);
     if (!info.pid)
       continue;
 
-    info.type = iter.GetData().type;
+    info.process_type = iter.GetData().process_type;
     info.renderer_type = ProcessMemoryInformation::RENDERER_UNKNOWN;
     info.titles.push_back(iter.GetData().name);
     child_info.push_back(info);
   }
 
   // Now go do expensive memory lookups from the file thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&MemoryDetails::CollectProcessData, this, child_info));
 }
@@ skipping 21 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 = content::PROCESS_TYPE_RENDERER;
+      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 = NULL;
       // No extensions on Android. So extension_service can be NULL.
       if (extension_service)
           extension_process_map = extension_service->process_map();
 
       // The RenderProcessHost may host multiple WebContentses.  Any
@@ skipping 97 matching lines @@
                                   chrome::kChromeUIMemoryURL)) ||
             (pending_entry &&
              LowerCaseEqualsASCII(pending_entry->GetVirtualURL().spec(),
                                   chrome::kChromeUIMemoryURL)))
           process.is_diagnostics = true;
       }
     }
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
     if (process.pid == zygote_pid) {
-      process.type = content::PROCESS_TYPE_ZYGOTE;
+      process.process_type = content::PROCESS_TYPE_ZYGOTE;
     } else if (process.pid == sandbox_helper_pid) {
-      process.type = content::PROCESS_TYPE_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 ==
+    if (chrome_browser->processes[index].process_type ==
         content::PROCESS_TYPE_UNKNOWN) {
       chrome_browser->processes.erase(
           chrome_browser->processes.begin() + index);
       index--;
     }
   }
 
   if (user_metrics_mode_ == UPDATE_USER_METRICS)
     UpdateHistograms();
 
@@ skipping 10 matching lines @@
   int extension_count = 0;
   int plugin_count = 0;
   int pepper_plugin_count = 0;
   int pepper_plugin_broker_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) {
+    switch (browser.processes[index].process_type) {
       case content::PROCESS_TYPE_BROWSER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Browser", sample);
         break;
       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++;
@@ skipping 27 matching lines @@
         other_count++;
         break;
       case content::PROCESS_TYPE_ZYGOTE:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Zygote", sample);
         other_count++;
         break;
       case content::PROCESS_TYPE_SANDBOX_HELPER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.SandboxHelper", sample);
         other_count++;
         break;
-      case content::PROCESS_TYPE_NACL_LOADER:
-        UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
-        other_count++;
-        break;
-      case content::PROCESS_TYPE_NACL_BROKER:
-        UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
-        other_count++;
-        break;
       case content::PROCESS_TYPE_GPU:
         UMA_HISTOGRAM_MEMORY_KB("Memory.Gpu", sample);
         other_count++;
         break;
       case content::PROCESS_TYPE_PPAPI_PLUGIN:
         UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPlugin", sample);
         pepper_plugin_count++;
         break;
       case content::PROCESS_TYPE_PPAPI_BROKER:
         UMA_HISTOGRAM_MEMORY_KB("Memory.PepperPluginBroker", sample);
         pepper_plugin_broker_count++;
         break;
+      case PROCESS_TYPE_NACL_LOADER:
+        UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClient", sample);
+        other_count++;
+        break;
+      case PROCESS_TYPE_NACL_BROKER:
+        UMA_HISTOGRAM_MEMORY_KB("Memory.NativeClientBroker", sample);
+        other_count++;
+        break;
       default:
         NOTREACHED();
         break;
     }
   }
   UMA_HISTOGRAM_MEMORY_KB("Memory.BackingStore",
                           RenderWidgetHost::BackingStoreMemorySize() / 1024);
 #if defined(OS_CHROMEOS)
   // Chrome OS exposes system-wide graphics driver memory which has historically
   // been a source of leak/bloat.
@@ skipping 13 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Memory.PepperPluginBrokerProcessCount",
       pepper_plugin_broker_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);
 }