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

chrome/browser/extensions/extension_process_manager.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.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/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 
 using content::BrowserThread;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::SiteInstance;
+using content::WebContents;
 using extensions::Extension;
 
 namespace {
 
 std::string GetExtensionID(RenderViewHost* render_view_host) {
   // This works for both apps and extensions because the site has been
   // normalized to the extension URL for apps.
   if (!render_view_host->GetSiteInstance())
     return "";
 
   return render_view_host->GetSiteInstance()->GetSite().host();
 }
 
 // Incognito profiles use this process manager. It is mostly a shim that decides
 // whether to fall back on the original profile's ExtensionProcessManager based
 // on whether a given extension uses "split" or "spanning" incognito behavior.
 class IncognitoExtensionProcessManager : public ExtensionProcessManager {
  public:
   explicit IncognitoExtensionProcessManager(Profile* profile);
   virtual ~IncognitoExtensionProcessManager() {}
   virtual ExtensionHost* CreateViewHost(
       const Extension* extension,
       const GURL& url,
       Browser* browser,
-      content::ViewType view_type) OVERRIDE;
+      chrome::ViewType view_type) OVERRIDE;
   virtual void CreateBackgroundHost(const Extension* extension,
                                     const GURL& url);
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url);
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
 
@@ skipping 90 matching lines @@
   }
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
 
 void ExtensionProcessManager::EnsureBrowserWhenRequired(
     Browser* browser,
-    content::ViewType view_type) {
+    chrome::ViewType view_type) {
   if (!browser) {
 #if defined (OS_CHROMEOS)
   // On ChromeOS we'll only use ExtensionView, which
   // does not use the browser parameter.
   // TODO(rkc): Remove all this once we create a new host for
   // screensaver extensions (crosbug.com/28211).
   DCHECK(view_type == chrome::VIEW_TYPE_EXTENSION_POPUP ||
          view_type == chrome::VIEW_TYPE_EXTENSION_DIALOG);
 #else
   // A NULL browser may only be given for pop-up views.
   DCHECK(view_type == chrome::VIEW_TYPE_EXTENSION_POPUP);
 #endif
   }
 }
 
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
-    content::ViewType view_type) {
+    chrome::ViewType view_type) {
   DCHECK(extension);
   EnsureBrowserWhenRequired(browser, view_type);
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new ExtensionHostMac(extension, GetSiteInstanceForURL(url), url,
                            view_type);
 #else
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url, view_type);
 #endif
   host->CreateView(browser);
   OnExtensionHostCreated(host, false);
   return host;
 }
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
-    const GURL& url, Browser* browser, content::ViewType view_type) {
+    const GURL& url, Browser* browser, chrome::ViewType view_type) {
   EnsureBrowserWhenRequired(browser, view_type);
   ExtensionService* service = GetProfile()->GetExtensionService();
   if (service) {
     const Extension* extension =
         service->extensions()->GetByID(url.host());
     if (extension)
       return CreateViewHost(extension, url, browser, view_type);
   }
   return NULL;
 }
@@ skipping 105 matching lines @@
     return NULL;
 
   ExtensionService* service =
       ExtensionSystem::Get(GetProfile())->extension_service();
   return service->extensions()->GetByID(GetExtensionID(render_view_host));
 }
 
 void ExtensionProcessManager::RegisterRenderViewHost(
     RenderViewHost* render_view_host,
     const Extension* extension) {
-  all_extension_views_[render_view_host] = content::VIEW_TYPE_INVALID;
+  all_extension_views_[render_view_host] = chrome::VIEW_TYPE_INVALID;
 }
 
 void ExtensionProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_VIEW_UNREGISTERED,
       content::Source<Profile>(GetProfile()),
       content::Details<RenderViewHost>(render_view_host));
 
-  content::ViewType view_type = view->second;
+  chrome::ViewType view_type = view->second;
   all_extension_views_.erase(view);
 
   // Keepalive count, balanced in UpdateRegisteredRenderView.
-  if (view_type != content::VIEW_TYPE_INVALID &&
+  if (view_type != chrome::VIEW_TYPE_INVALID &&
       view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
       DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::UpdateRegisteredRenderView(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_VIEW_REGISTERED,
       content::Source<Profile>(GetProfile()),
       content::Details<RenderViewHost>(render_view_host));
 
-  view->second = render_view_host->GetDelegate()->GetRenderViewType();
+  WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
+  view->second = chrome::GetViewType(web_contents);
 
   // Keep the lazy background page alive as long as any non-background-page
   // extension views are visible. Keepalive count balanced in
   // UnregisterRenderViewHost.
   IncrementLazyKeepaliveCountForView(render_view_host);
 }
 
 SiteInstance* ExtensionProcessManager::GetSiteInstanceForURL(const GURL& url) {
   return site_instance_->GetRelatedSiteInstance(url);
 }
@@ skipping 36 matching lines @@
         base::Bind(&ExtensionProcessManager::OnLazyBackgroundPageIdle,
                    weak_ptr_factory_.GetWeakPtr(), extension->id(),
                    ++background_page_data_[extension->id()].close_sequence_id),
         event_page_idle_time_);
   }
 
   return count;
 }
 void ExtensionProcessManager::IncrementLazyKeepaliveCountForView(
     RenderViewHost* render_view_host) {
-  content::ViewType view_type =
-      render_view_host->GetDelegate()->GetRenderViewType();
-  if (view_type != content::VIEW_TYPE_INVALID &&
+  WebContents* web_contents =
+      WebContents::FromRenderViewHost(render_view_host);
+  chrome::ViewType view_type = chrome::GetViewType(web_contents);
+  if (view_type != chrome::VIEW_TYPE_INVALID &&
       view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
       IncrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::OnLazyBackgroundPageIdle(
     const std::string& extension_id, int sequence_id) {
@@ skipping 131 matching lines @@
       // Close background hosts when the last browser is closed so that they
       // have time to shutdown various objects on different threads. Our
       // destructor is called too late in the shutdown sequence.
       CloseBackgroundHosts();
       break;
     }
 
     case content::NOTIFICATION_DEVTOOLS_WINDOW_OPENING: {
       RenderViewHost* render_view_host =
           content::Details<RenderViewHost>(details).ptr();
+      WebContents* web_contents =
+          WebContents::FromRenderViewHost(render_view_host);
       // Keep the lazy background page alive while it's being inspected.
       // Balanced in response to the CLOSING notification.
-      if (render_view_host->GetDelegate()->GetRenderViewType() ==
+      if (chrome::GetViewType(web_contents) ==
               chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         const Extension* extension = GetExtensionForRenderViewHost(
             render_view_host);
         if (extension)
           IncrementLazyKeepaliveCount(extension);
       }
       break;
     }
 
     case content::NOTIFICATION_DEVTOOLS_WINDOW_CLOSING: {
       RenderViewHost* render_view_host =
           content::Details<RenderViewHost>(details).ptr();
+      WebContents* web_contents =
+          WebContents::FromRenderViewHost(render_view_host);
       // Balanced in response to the OPENING notification.
-      if (render_view_host->GetDelegate()->GetRenderViewType() ==
+      if (chrome::GetViewType(web_contents) ==
               chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         const Extension* extension = GetExtensionForRenderViewHost(
             render_view_host);
         if (extension)
           DecrementLazyKeepaliveCount(extension);
       }
       break;
     }
 
     default:
@@ skipping 74 matching lines @@
        iter != all_extension_views_.end(); ++iter) {
     result.insert(iter->first);
   }
   return result;
 }
 
 ExtensionHost* IncognitoExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
-    content::ViewType view_type) {
+    chrome::ViewType view_type) {
   if (extension->incognito_split_mode()) {
     if (IsIncognitoEnabled(extension)) {
       return ExtensionProcessManager::CreateViewHost(extension, url,
                                                      browser, view_type);
     } else {
       NOTREACHED() <<
           "We shouldn't be trying to create an incognito extension view unless "
           "it has been enabled for incognito.";
       return NULL;
     }
@@ skipping 51 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup(this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }