Refactor RenderProcessHost to use IPC::Listener instead of RenderWidgetHost

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"
@@ skipping 196 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 (content::RenderProcessHost::iterator renderer_iter(
-            content::RenderProcessHost::AllHostsIterator());
-         !renderer_iter.IsAtEnd(); renderer_iter.Advance()) {
+    RenderWidgetHost::List widgets = RenderWidgetHost::GetRenderWidgetHosts();
+    for (size_t i = 0; i < widgets.size(); ++i) {
       content::RenderProcessHost* render_process_host =
-          renderer_iter.GetCurrentValue();
+          widgets[i]->GetProcess();
       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.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
       // of them which contain diagnostics information make the whole
       // process be considered a diagnostics process.
-      content::RenderProcessHost::RenderWidgetHostsIterator iter(
-          render_process_host->GetRenderWidgetHostsIterator());
-      for (; !iter.IsAtEnd(); iter.Advance()) {
-        const RenderWidgetHost* widget = iter.GetCurrentValue();
-        DCHECK(widget);
-        if (!widget || !widget->IsRenderView())
-          continue;
+      if (!widgets[i]->IsRenderView())
+        continue;
 
-        RenderViewHost* host =
-            RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
-        WebContents* contents = WebContents::FromRenderViewHost(host);
-        GURL url;
-        if (contents) {
-          url = contents->GetURL();
-          SiteData* site_data =
-              &chrome_browser->site_data[contents->GetBrowserContext()];
-          SiteDetails::CollectSiteInfo(contents, site_data);
-        }
-        extensions::ViewType type = extensions::GetViewType(contents);
-        if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
-          process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
-        } else if (extension_process_map &&
-            extension_process_map->Contains(host->GetProcess()->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->GetProcess()->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 =
-                  ProcessMemoryInformation::RENDERER_EXTENSION;
-              break;
-            }
+      RenderViewHost* host = RenderViewHost::From(widgets[i]);
+      WebContents* contents = WebContents::FromRenderViewHost(host);
+      GURL url;
+      if (contents) {
+        url = contents->GetURL();
+        SiteData* site_data =
+            &chrome_browser->site_data[contents->GetBrowserContext()];
+        SiteDetails::CollectSiteInfo(contents, site_data);
+      }
+      extensions::ViewType type = extensions::GetViewType(contents);
+      if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
+        process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
+      } else if (extension_process_map &&
+                 extension_process_map->Contains(host->GetProcess()->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->GetProcess()->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 =
+                ProcessMemoryInformation::RENDERER_EXTENSION;
+            break;
           }
         }
-        if (extension_process_map &&
-            extension_process_map->Contains(host->GetProcess()->GetID())) {
-          const Extension* extension =
-              extension_service->extensions()->GetByID(url.host());
-          if (extension) {
-            string16 title = UTF8ToUTF16(extension->name());
-            process.titles.push_back(title);
-            process.renderer_type =
-                ProcessMemoryInformation::RENDERER_EXTENSION;
-            continue;
-          }
-        }
-
-        if (!contents) {
+      }
+      if (extension_process_map &&
+          extension_process_map->Contains(host->GetProcess()->GetID())) {
+        const Extension* extension =
+            extension_service->extensions()->GetByID(url.host());
+        if (extension) {
+          string16 title = UTF8ToUTF16(extension->name());
+          process.titles.push_back(title);
           process.renderer_type =
-                ProcessMemoryInformation::RENDERER_INTERSTITIAL;
+              ProcessMemoryInformation::RENDERER_EXTENSION;
           continue;
         }
+      }
 
-        if (type == extensions::VIEW_TYPE_BACKGROUND_CONTENTS) {
-          process.titles.push_back(UTF8ToUTF16(url.spec()));
-          process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
-          continue;
-        }
+      if (!contents) {
+        process.renderer_type =
+            ProcessMemoryInformation::RENDERER_INTERSTITIAL;
+        continue;
+      }
 
-        if (type == extensions::VIEW_TYPE_NOTIFICATION) {
-          process.titles.push_back(UTF8ToUTF16(url.spec()));
-          process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_NOTIFICATION;
-          continue;
-        }
+      if (type == extensions::VIEW_TYPE_BACKGROUND_CONTENTS) {
+        process.titles.push_back(UTF8ToUTF16(url.spec()));
+        process.renderer_type =
+            ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
+        continue;
+      }
 
-        // Since we have a WebContents and and the renderer type hasn't been
-        // set yet, it must be a normal tabbed renderer.
-        if (process.renderer_type == ProcessMemoryInformation::RENDERER_UNKNOWN)
-          process.renderer_type = ProcessMemoryInformation::RENDERER_NORMAL;
+      if (type == extensions::VIEW_TYPE_NOTIFICATION) {
+        process.titles.push_back(UTF8ToUTF16(url.spec()));
+        process.renderer_type =
+            ProcessMemoryInformation::RENDERER_NOTIFICATION;
+        continue;
+      }
 
-        string16 title = contents->GetTitle();
-        if (!title.length())
-          title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
-        process.titles.push_back(title);
+      // Since we have a WebContents and and the renderer type hasn't been
+      // set yet, it must be a normal tabbed renderer.
+      if (process.renderer_type == ProcessMemoryInformation::RENDERER_UNKNOWN)
+        process.renderer_type = ProcessMemoryInformation::RENDERER_NORMAL;
 
-        // We need to check the pending entry as well as the virtual_url to
-        // see if it's a chrome://memory URL (we don't want to count these in
-        // the total memory usage of the browser).
-        //
-        // When we reach here, chrome://memory will be the pending entry since
-        // we haven't responded with any data such that it would be committed.
-        // If you have another chrome://memory tab open (which would be
-        // committed), we don't want to count it either, so we also check the
-        // last committed entry.
-        //
-        // Either the pending or last committed entries can be NULL.
-        const NavigationEntry* pending_entry =
-            contents->GetController().GetPendingEntry();
-        const NavigationEntry* last_committed_entry =
-            contents->GetController().GetLastCommittedEntry();
-        if ((last_committed_entry &&
-             LowerCaseEqualsASCII(last_committed_entry->GetVirtualURL().spec(),
-                                  chrome::kChromeUIMemoryURL)) ||
-            (pending_entry &&
-             LowerCaseEqualsASCII(pending_entry->GetVirtualURL().spec(),
-                                  chrome::kChromeUIMemoryURL)))
-          process.is_diagnostics = true;
+      string16 title = contents->GetTitle();
+      if (!title.length())
+        title = l10n_util::GetStringUTF16(IDS_DEFAULT_TAB_TITLE);
+      process.titles.push_back(title);
+
+      // We need to check the pending entry as well as the virtual_url to
+      // see if it's a chrome://memory URL (we don't want to count these in
+      // the total memory usage of the browser).
+      //
+      // When we reach here, chrome://memory will be the pending entry since
+      // we haven't responded with any data such that it would be committed.
+      // If you have another chrome://memory tab open (which would be
+      // committed), we don't want to count it either, so we also check the
+      // last committed entry.
+      //
+      // Either the pending or last committed entries can be NULL.
+      const NavigationEntry* pending_entry =
+          contents->GetController().GetPendingEntry();
+      const NavigationEntry* last_committed_entry =
+          contents->GetController().GetLastCommittedEntry();
+      if ((last_committed_entry &&
+           LowerCaseEqualsASCII(last_committed_entry->GetVirtualURL().spec(),
+                                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.process_type = content::PROCESS_TYPE_ZYGOTE;
     } else if (process.pid == sandbox_helper_pid) {
       process.process_type = content::PROCESS_TYPE_SANDBOX_HELPER;
     }
 #endif
@@ skipping 136 matching lines @@
   int total_sample = static_cast<int>(aggregate_memory / 1000);
   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
 
   // Predict the number of processes needed when isolating all sites and when
   // isolating only HTTPS sites.
   int all_renderer_count = renderer_count + chrome_count + extension_count;
   int non_renderer_count = browser.processes.size() - all_renderer_count;
   SiteDetails::UpdateHistograms(browser.site_data, all_renderer_count,
                                 non_renderer_count);
 }