Define the public version of the browser side RenderProcessHost interface. This interface is not ...

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_process_host.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/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"
 #endif
 
@@ skipping 87 matching lines @@
   ProcessData* const chrome_browser = ChromeBrowser();
   // Get more information about the process.
   for (size_t index = 0; index < chrome_browser->processes.size();
       index++) {
     // Check if it's a renderer, if so get the list of page titles in it and
     // check if it's a diagnostics-related process.  We skip about:memory pages.
     // Iterate the RenderProcessHosts to find the tab contents.
     ProcessMemoryInformation& process =
         chrome_browser->processes[index];
 
-    for (RenderProcessHost::iterator renderer_iter(
-         RenderProcessHost::AllHostsIterator()); !renderer_iter.IsAtEnd();
-         renderer_iter.Advance()) {
-      RenderProcessHost* render_process_host = renderer_iter.GetCurrentValue();
+    for (content::RenderProcessHost::iterator renderer_iter(
+            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;
       Profile* profile =
-          Profile::FromBrowserContext(render_process_host->browser_context());
+          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.
       //
       // NOTE: This is a bit dangerous.  We know that for now, listeners
       //       are always RenderWidgetHosts.  But in theory, they don't
       //       have to be.
-      RenderProcessHost::listeners_iterator iter(
+      content::RenderProcessHost::listeners_iterator iter(
           render_process_host->ListenersIterator());
       for (; !iter.IsAtEnd(); iter.Advance()) {
         const RenderWidgetHost* widget =
             static_cast<const RenderWidgetHost*>(iter.GetCurrentValue());
         DCHECK(widget);
         if (!widget || !widget->IsRenderView())
           continue;
 
         const RenderViewHost* host = static_cast<const RenderViewHost*>(widget);
         RenderViewHostDelegate* host_delegate = host->delegate();
         DCHECK(host_delegate);
         GURL url = host_delegate->GetURL();
         content::ViewType type = host_delegate->GetRenderViewType();
         if (host->enabled_bindings() & content::BINDINGS_POLICY_WEB_UI) {
           // TODO(erikkay) the type for devtools doesn't actually appear to
           // be set.
           if (type == content::VIEW_TYPE_DEV_TOOLS_UI)
             process.renderer_type = ChildProcessInfo::RENDERER_DEVTOOLS;
           else
             process.renderer_type = ChildProcessInfo::RENDERER_CHROME;
-        } else if (extension_process_map->Contains(host->process()->id())) {
+        } else if (extension_process_map->Contains(host->process()->GetID())) {
           // For our purposes, don't count processes containing only hosted apps
           // as extension processes. See also: crbug.com/102533.
           std::set<std::string> extension_ids =
               extension_process_map->GetExtensionsInProcess(
-                  host->process()->id());
+                  host->process()->GetID());
           for (std::set<std::string>::iterator iter = extension_ids.begin();
                iter != extension_ids.end(); ++iter) {
             const Extension* extension =
                 extension_service->GetExtensionById(*iter, false);
             if (extension && !extension->is_hosted_app()) {
               process.renderer_type = ChildProcessInfo::RENDERER_EXTENSION;
               break;
             }
           }
         }
         TabContents* contents = host_delegate->GetAsTabContents();
         if (!contents) {
-          if (extension_process_map->Contains(host->process()->id())) {
+          if (extension_process_map->Contains(host->process()->GetID())) {
             const Extension* extension =
                 extension_service->GetExtensionByURL(url);
             if (extension) {
               string16 title = UTF8ToUTF16(extension->name());
               process.titles.push_back(title);
             }
           } else if (process.renderer_type ==
                      ChildProcessInfo::RENDERER_UNKNOWN) {
             process.titles.push_back(UTF8ToUTF16(url.spec()));
             switch (type) {
@@ skipping 172 matching lines @@
   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);
 }