Get rid of the RenderViewType concept in content, since it was only used by Chrome. Store the enum…

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/common/chrome_view_type.h"
+#include "chrome/browser/view_type_utils.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/render_view_host_delegate.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
@@ skipping 197 matching lines @@
       // 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;
 
-        const RenderViewHost* host =
+        RenderViewHost* host =
             RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
-        content::RenderViewHostDelegate* host_delegate = host->GetDelegate();
-        DCHECK(host_delegate);
-        GURL url = host_delegate->GetURL();
-        content::ViewType type = host_delegate->GetRenderViewType();
+        WebContents* contents = WebContents::FromRenderViewHost(host);
+        GURL url;
+        if (contents)
+          url = contents->GetURL();
+        chrome::ViewType type = chrome::GetViewType(contents);
         if (host->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI) {
           process.renderer_type = ProcessMemoryInformation::RENDERER_CHROME;
         } 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->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->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) {
-              case chrome::VIEW_TYPE_BACKGROUND_CONTENTS:
-                process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
-                break;
-              case content::VIEW_TYPE_INTERSTITIAL_PAGE:
-                process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_INTERSTITIAL;
-                break;
-              case chrome::VIEW_TYPE_NOTIFICATION:
-                process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_NOTIFICATION;
-                break;
-              default:
-                process.renderer_type =
-                    ProcessMemoryInformation::RENDERER_UNKNOWN;
-                break;
-            }
+        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);
           }
           continue;
         }
 
-        // Since We have a WebContents and and the renderer type hasn't been
+        if (!contents) {
+          process.renderer_type =
+                ProcessMemoryInformation::RENDERER_INTERSTITIAL;
+          continue;
+        }
+
+        if (type == chrome::VIEW_TYPE_BACKGROUND_CONTENTS) {
+          process.titles.push_back(UTF8ToUTF16(url.spec()));
+          process.renderer_type =
+                    ProcessMemoryInformation::RENDERER_BACKGROUND_APP;
+          continue;
+        }
+
+        if (type == chrome::VIEW_TYPE_NOTIFICATION) {
+          process.titles.push_back(UTF8ToUTF16(url.spec()));
+          process.renderer_type =
+                    ProcessMemoryInformation::RENDERER_NOTIFICATION;
+          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;
 
         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
@@ skipping 144 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);
 }