Extract minimal RenderViewHost interface for embedders, leaving

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 188 matching lines @@
       //       have to be.
       content::RenderProcessHost::listeners_iterator iter(
           render_process_host->ListenersIterator());
       for (; !iter.IsAtEnd(); iter.Advance()) {
         const RenderWidgetHost* widget =
             RenderWidgetHost::FromIPCChannelListener(iter.GetCurrentValue());
         DCHECK(widget);
         if (!widget || !widget->IsRenderView())
           continue;
 
-        const RenderViewHost* host = static_cast<const RenderViewHost*>(widget);
-        content::RenderViewHostDelegate* host_delegate = host->delegate();
+        const RenderViewHost* host = static_cast<const RenderViewHostImpl*>(
+            const_cast<RenderWidgetHost*>(widget)->AsRWHImpl());

[jam, 2012/02/29 01:40:47]

nit: i guess this (and other usage in chrome) is a todo? (no need to add it now,
just want to make sure for my own knowledge)

we have similar loops in other places, perhaps what we really need is just to
have RenderProcessHost have a RenderViewHost iterator on it, and inside content
we do this casting and also the FromIPCChannelListener stuff (of course not in
this change)

[Jói, 2012/03/02 10:40:36]

Ah, this was an oversight.  Once I move RenderWidgetHost and RenderViewHost to
their own files and allow Chrome only to #include those, this cast won't work;
I'll figure out a solution, possibly converting the iterator as you suggested.

+        content::RenderViewHostDelegate* host_delegate = host->GetDelegate();
         DCHECK(host_delegate);
         GURL url = host_delegate->GetURL();
         content::ViewType type = host_delegate->GetRenderViewType();
-        if (host->enabled_bindings() & content::BINDINGS_POLICY_WEB_UI) {
+        if (host->GetEnabledBindings() & 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 = ProcessMemoryInformation::RENDERER_DEVTOOLS;
           else
             process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
-        } else if (extension_process_map->Contains(host->process()->GetID())) {
+        } else if (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->process()->GetID());
+                  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;
             }
           }
         }
         WebContents* contents = host_delegate->GetAsWebContents();
         if (!contents) {
-          if (extension_process_map->Contains(host->process()->GetID())) {
+          if (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);
             }
           } else if (process.renderer_type ==
                      ProcessMemoryInformation::RENDERER_UNKNOWN) {
             process.titles.push_back(UTF8ToUTF16(url.spec()));
             switch (type) {
@@ skipping 175 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);
 }