Move the ViewType enum to extensions\common.

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 "chrome/browser/extensions/extension_process_manager.h"
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
-#include "chrome/browser/extensions/extension_process_manager.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/ui/tabs/tab_strip_model.h"
-#include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.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/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/renderer_preferences.h"
+#include "extensions/browser/view_type_utils.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;
@@ skipping 18 matching lines @@
 // 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,
-      chrome::ViewType view_type) OVERRIDE;
+      extensions::ViewType view_type) OVERRIDE;
   virtual void CreateBackgroundHost(const Extension* extension,
                                     const GURL& url) OVERRIDE;
   virtual SiteInstance* GetSiteInstanceForURL(const GURL& url) OVERRIDE;
 
  private:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
@@ skipping 104 matching lines @@
   for (ExtensionRenderViews::const_iterator iter =
            all_extension_views_.begin();
        iter != all_extension_views_.end(); ++iter) {
     result.insert(iter->first);
   }
   return result;
 }
 
 void ExtensionProcessManager::EnsureBrowserWhenRequired(
     Browser* browser,
-    chrome::ViewType view_type) {
+    extensions::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);
+  DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP ||
+         view_type == extensions::VIEW_TYPE_EXTENSION_DIALOG);
 #else
   // A NULL browser may only be given for pop-up views.
-  DCHECK(view_type == chrome::VIEW_TYPE_EXTENSION_POPUP);
+  DCHECK(view_type == extensions::VIEW_TYPE_EXTENSION_POPUP);
 #endif
   }
 }
 
 
 ExtensionHost* ExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
-    chrome::ViewType view_type) {
+    extensions::ViewType view_type) {
   DCHECK(extension);
   EnsureBrowserWhenRequired(browser, view_type);
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new extensions::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, chrome::ViewType view_type) {
+    const GURL& url, Browser* browser, extensions::ViewType view_type) {
   EnsureBrowserWhenRequired(browser, view_type);
   ExtensionService* service = GetProfile()->GetExtensionService();
   if (service) {
     std::string extension_id = url.host();
     if (url.SchemeIs(chrome::kChromeUIScheme) &&
         url.host() == chrome::kChromeUIExtensionInfoHost)
       extension_id = url.path().substr(1);
     const Extension* extension =
         service->extensions()->GetByID(extension_id);
     if (extension)
       return CreateViewHost(extension, url, browser, view_type);
   }
   return NULL;
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopupHost(
     const Extension* extension, const GURL& url, Browser* browser) {
   return CreateViewHost(
-      extension, url, browser, chrome::VIEW_TYPE_EXTENSION_POPUP);
+      extension, url, browser, extensions::VIEW_TYPE_EXTENSION_POPUP);
 }
 
 ExtensionHost* ExtensionProcessManager::CreatePopupHost(
     const GURL& url, Browser* browser) {
-  return CreateViewHost(url, browser, chrome::VIEW_TYPE_EXTENSION_POPUP);
+  return CreateViewHost(url, browser, extensions::VIEW_TYPE_EXTENSION_POPUP);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateDialogHost(const GURL& url) {
-  return CreateViewHost(url, NULL, chrome::VIEW_TYPE_EXTENSION_DIALOG);
+  return CreateViewHost(url, NULL, extensions::VIEW_TYPE_EXTENSION_DIALOG);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateInfobarHost(
     const Extension* extension, const GURL& url, Browser* browser) {
   return CreateViewHost(
-      extension, url, browser, chrome::VIEW_TYPE_EXTENSION_INFOBAR);
+      extension, url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
 }
 
 ExtensionHost* ExtensionProcessManager::CreateInfobarHost(
     const GURL& url, Browser* browser) {
-  return CreateViewHost(url, browser, chrome::VIEW_TYPE_EXTENSION_INFOBAR);
+  return CreateViewHost(url, browser, extensions::VIEW_TYPE_EXTENSION_INFOBAR);
 }
 
 void ExtensionProcessManager::CreateBackgroundHost(
     const Extension* extension, const GURL& url) {
   // Hosted apps are taken care of from BackgroundContentsService. Ignore them
   // here.
   if (extension->is_hosted_app())
     return;
 
   // Don't create multiple background hosts for an extension.
   if (GetBackgroundHostForExtension(extension->id()))
     return;
 
   ExtensionHost* host =
 #if defined(OS_MACOSX)
       new extensions::ExtensionHostMac(
           extension, GetSiteInstanceForURL(url), url,
-          chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
+          extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 #else
       new ExtensionHost(extension, GetSiteInstanceForURL(url), url,
-                        chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
+                        extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
 #endif
 
   host->CreateRenderViewSoon();
   OnExtensionHostCreated(host, true);
 }
 
 void ExtensionProcessManager::OpenOptionsPage(const Extension* extension,
                                               Browser* browser) {
   DCHECK(!extensions::ManifestURL::GetOptionsPage(extension).is_empty());
 
@@ skipping 64 matching lines @@
   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));
 
-  chrome::ViewType view_type = view->second;
+  extensions::ViewType view_type = view->second;
   all_extension_views_.erase(view);
 
   // Keepalive count, balanced in RegisterRenderViewHost.
-  if (view_type != chrome::VIEW_TYPE_INVALID &&
-      view_type != chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+  if (view_type != extensions::VIEW_TYPE_INVALID &&
+      view_type != extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
     const Extension* extension = GetExtensionForRenderViewHost(
         render_view_host);
     if (extension)
       DecrementLazyKeepaliveCount(extension);
   }
 }
 
 void ExtensionProcessManager::RegisterRenderViewHost(
     RenderViewHost* render_view_host) {
   const Extension* extension = GetExtensionForRenderViewHost(
       render_view_host);
   if (!extension)
     return;
 
   WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
-  all_extension_views_[render_view_host] = chrome::GetViewType(web_contents);
+  all_extension_views_[render_view_host] =
+      extensions::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 39 matching lines @@
         event_page_idle_time_);
   }
 
   return count;
 }
 
 void ExtensionProcessManager::IncrementLazyKeepaliveCountForView(
     RenderViewHost* render_view_host) {
   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) {
+  extensions::ViewType view_type = extensions::GetViewType(web_contents);
+  if (view_type != extensions::VIEW_TYPE_INVALID &&
+      view_type != extensions::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) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
@@ skipping 148 matching lines @@
         ClearBackgroundPageData(host->extension()->id());
         background_page_data_[host->extension()->id()].since_suspended.reset(
             new PerfTimer());
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       if (host->extension_host_type() ==
-          chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+          extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         CloseBackgroundHost(host);
       }
       break;
     }
 
     case content::NOTIFICATION_WEB_CONTENTS_SWAPPED: {
       // We get this notification both for new WebContents and when one
       // has its RenderViewHost replaced (e.g. when a user does a cross-site
       // navigation away from an extension URL). For the replaced case, we must
       // unregister the old RVH so it doesn't count as an active view that would
@@ skipping 38 matching lines @@
       break;
     }
 
     case content::NOTIFICATION_DEVTOOLS_AGENT_ATTACHED: {
       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 (chrome::GetViewType(web_contents) ==
-              chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+      if (extensions::GetViewType(web_contents) ==
+              extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         const Extension* extension = GetExtensionForRenderViewHost(
             render_view_host);
         if (extension) {
           CancelSuspend(extension);
           IncrementLazyKeepaliveCount(extension);
         }
       }
       break;
     }
 
     case content::NOTIFICATION_DEVTOOLS_AGENT_DETACHED: {
       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 (chrome::GetViewType(web_contents) ==
-              chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+      if (extensions::GetViewType(web_contents) ==
+              extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
         const Extension* extension = GetExtensionForRenderViewHost(
             render_view_host);
         if (extension)
           DecrementLazyKeepaliveCount(extension);
       }
       break;
     }
 
     default:
       NOTREACHED();
@@ skipping 33 matching lines @@
       if (since_suspended.get()) {
         UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
                                  since_suspended->Elapsed());
       }
     }
   }
 }
 
 void ExtensionProcessManager::CloseBackgroundHost(ExtensionHost* host) {
   CHECK(host->extension_host_type() ==
-        chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
+        extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   delete host;
   // |host| should deregister itself from our structures.
   CHECK(background_hosts_.find(host) == background_hosts_.end());
 }
 
 void ExtensionProcessManager::CloseBackgroundHosts() {
   for (ExtensionHostSet::iterator iter = background_hosts_.begin();
        iter != background_hosts_.end(); ) {
     ExtensionHostSet::iterator current = iter++;
     delete *current;
@@ skipping 48 matching lines @@
   ExtensionService* service =
       extensions::ExtensionSystem::Get(GetProfile())->extension_service();
   if (service)
     service->menu_manager()->RemoveAllIncognitoContextItems();
 }
 
 ExtensionHost* IncognitoExtensionProcessManager::CreateViewHost(
     const Extension* extension,
     const GURL& url,
     Browser* browser,
-    chrome::ViewType view_type) {
+    extensions::ViewType view_type) {
   if (extensions::IncognitoInfo::IsSplitMode(extension)) {
     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 55 matching lines @@
         if (service && service->is_ready())
           CreateBackgroundHostsForProfileStartup();
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }