Move the ViewType enum to extensions\common.

chrome/browser/extensions/extension_host.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_host.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/memory/singleton.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_modal_dialogs/javascript_dialog_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/prefs/prefs_tab_helper.h"
-#include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/request_media_access_permission_helper.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/native_web_keyboard_event.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_view.h"
+#include "extensions/browser/view_type_utils.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 using content::NativeWebKeyboardEvent;
@@ skipping 60 matching lines @@
   bool pending_create_;
   base::WeakPtrFactory<ProcessCreationQueue> ptr_factory_;
 };
 
 ////////////////
 // ExtensionHost
 
 ExtensionHost::ExtensionHost(const Extension* extension,
                              SiteInstance* site_instance,
                              const GURL& url,
-                             chrome::ViewType host_type)
+                             ViewType host_type)
     : extension_(extension),
       extension_id_(extension->id()),
       profile_(Profile::FromBrowserContext(
           site_instance->GetBrowserContext())),
       render_view_host_(NULL),
       did_stop_loading_(false),
       document_element_available_(false),
       initial_url_(url),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           extension_function_dispatcher_(profile_, this)),
       extension_host_type_(host_type),
       associated_web_contents_(NULL) {
   host_contents_.reset(WebContents::Create(
       WebContents::CreateParams(profile_, site_instance))),
   content::WebContentsObserver::Observe(host_contents_.get());
   host_contents_->SetDelegate(this);
-  chrome::SetViewType(host_contents_.get(), host_type);
+  SetViewType(host_contents_.get(), host_type);
 
   PrefsTabHelper::CreateForWebContents(host_contents());
 
   render_view_host_ = host_contents_->GetRenderViewHost();
 
   // Listen for when an extension is unloaded from the same profile, as it may
   // be the same extension that this points to.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 }
 
 ExtensionHost::~ExtensionHost() {
-  if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE &&
+  if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE &&
       extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
     UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime",
                              since_created_.Elapsed());
   }
   // Clear the extension's renderer process out from any WebContents
   // that might have it in their back history.
   // TODO(jyasskin): Remove this hack by making extension reloading
   // wait for renderer shutdown.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
@@ skipping 59 matching lines @@
     CreateRenderViewNow();
   } else {
     ProcessCreationQueue::GetInstance()->CreateSoon(this);
   }
 }
 
 void ExtensionHost::CreateRenderViewNow() {
   LoadInitialURL();
   if (is_background_page()) {
     DCHECK(IsRenderViewLive());
-    extensions::ExtensionSystem::Get(profile_)->extension_service()->
+    ExtensionSystem::Get(profile_)->extension_service()->
         DidCreateRenderViewForBackgroundPage(this);
   }
 }
 
-extensions::WindowController*
-ExtensionHost::GetExtensionWindowController() const {
+WindowController* ExtensionHost::GetExtensionWindowController() const {
   return view() && view()->browser() ?
       view()->browser()->extension_window_controller() : NULL;
 }
 
 const GURL& ExtensionHost::GetURL() const {
   return host_contents()->GetURL();
 }
 
 void ExtensionHost::LoadInitialURL() {
   if (!is_background_page() &&
-      !extensions::ExtensionSystem::Get(profile_)->extension_service()->
+      !ExtensionSystem::Get(profile_)->extension_service()->
           IsBackgroundPageReady(extension_)) {
     // Make sure the background page loads before any others.
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
                    content::Source<Extension>(extension_));
     return;
   }
 
   host_contents_->GetController().LoadURL(
       initial_url_, content::Referrer(), content::PAGE_TRANSITION_LINK,
       std::string());
 }
 
 void ExtensionHost::Close() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
       content::Source<Profile>(profile_),
       content::Details<ExtensionHost>(this));
 }
 
 void ExtensionHost::Observe(int type,
                             const content::NotificationSource& source,
                             const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY:
-      DCHECK(extensions::ExtensionSystem::Get(profile_)->extension_service()->
+      DCHECK(ExtensionSystem::Get(profile_)->extension_service()->
           IsBackgroundPageReady(extension_));
       LoadInitialURL();
       break;
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
       // The extension object will be deleted after this notification has been
       // sent. NULL it out so that dirty pointer issues don't arise in cases
       // when multiple ExtensionHost objects pointing to the same Extension are
       // present.
       if (extension_ == content::Details<UnloadedExtensionInfo>(details)->
           extension) {
@@ skipping 49 matching lines @@
   static const base::StringPiece css(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
       IDR_EXTENSIONS_INFOBAR_CSS));
 
   render_view_host()->InsertCSS(string16(), css.as_string());
 }
 
 void ExtensionHost::DidStopLoading(content::RenderViewHost* render_view_host) {
   bool notify = !did_stop_loading_;
   did_stop_loading_ = true;
-  if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_POPUP ||
-      extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_DIALOG ||
-      extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_INFOBAR ||
-      extension_host_type_ == chrome::VIEW_TYPE_PANEL) {
+  if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP ||
+      extension_host_type_ == VIEW_TYPE_EXTENSION_DIALOG ||
+      extension_host_type_ == VIEW_TYPE_EXTENSION_INFOBAR ||
+      extension_host_type_ == VIEW_TYPE_PANEL) {
 #if defined(TOOLKIT_VIEWS) || defined(OS_MACOSX)
     if (view())
       view()->DidStopLoading();
 #endif
   }
   if (notify) {
-    if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
+    if (extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
       if (extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_)) {
         UMA_HISTOGRAM_TIMES("Extensions.EventPageLoadTime",
                             since_created_.Elapsed());
       } else {
         UMA_HISTOGRAM_TIMES("Extensions.BackgroundPageLoadTime",
                             since_created_.Elapsed());
       }
-    } else if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_DIALOG) {
+    } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_DIALOG) {
       UMA_HISTOGRAM_TIMES("Extensions.DialogLoadTime",
                           since_created_.Elapsed());
-    } else if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_POPUP) {
+    } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP) {
       UMA_HISTOGRAM_TIMES("Extensions.PopupLoadTime",
                           since_created_.Elapsed());
-    } else if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_INFOBAR) {
+    } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_INFOBAR) {
       UMA_HISTOGRAM_TIMES("Extensions.InfobarLoadTime",
         since_created_.Elapsed());
-    } else if (extension_host_type_ == chrome::VIEW_TYPE_PANEL) {
+    } else if (extension_host_type_ == VIEW_TYPE_PANEL) {
       UMA_HISTOGRAM_TIMES("Extensions.PanelLoadTime", since_created_.Elapsed());
     }
 
     // Send the notification last, because it might result in this being
     // deleted.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
         content::Source<Profile>(profile_),
         content::Details<ExtensionHost>(this));
   }
 }
 
 void ExtensionHost::DocumentAvailableInMainFrame() {
   // If the document has already been marked as available for this host, then
   // bail. No need for the redundant setup. http://crbug.com/31170
   if (document_element_available_)
     return;
 
   document_element_available_ = true;
   if (is_background_page()) {
-    extensions::ExtensionSystem::Get(profile_)->extension_service()->
+    ExtensionSystem::Get(profile_)->extension_service()->
         SetBackgroundPageReady(extension_);
   } else {
     switch (extension_host_type_) {
-      case chrome::VIEW_TYPE_EXTENSION_INFOBAR:
+      case VIEW_TYPE_EXTENSION_INFOBAR:
         InsertInfobarCSS();
         break;
       default:
         break;  // No style sheet for other types, at the moment.
     }
   }
 }
 
 void ExtensionHost::CloseContents(WebContents* contents) {
   // TODO(mpcomplete): is this check really necessary?
-  if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_POPUP ||
-      extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_DIALOG ||
-      extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE ||
-      extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_INFOBAR ||
-      extension_host_type_ == chrome::VIEW_TYPE_PANEL) {
+  if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP ||
+      extension_host_type_ == VIEW_TYPE_EXTENSION_DIALOG ||
+      extension_host_type_ == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE ||
+      extension_host_type_ == VIEW_TYPE_EXTENSION_INFOBAR ||
+      extension_host_type_ == VIEW_TYPE_PANEL) {
     Close();
   }
 }
 
 void ExtensionHost::WillRunJavaScriptDialog() {
   ExtensionProcessManager* pm =
       ExtensionSystem::Get(profile_)->process_manager();
   if (pm)
     pm->IncrementLazyKeepaliveCount(extension());
 }
@@ skipping 22 matching lines @@
       return browser ? browser->OpenURL(params) : NULL;
     }
     default:
       return NULL;
   }
 }
 
 bool ExtensionHost::PreHandleKeyboardEvent(WebContents* source,
                                            const NativeWebKeyboardEvent& event,
                                            bool* is_keyboard_shortcut) {
-  if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_POPUP &&
+  if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP &&
       event.type == NativeWebKeyboardEvent::RawKeyDown &&
       event.windowsKeyCode == ui::VKEY_ESCAPE) {
     DCHECK(is_keyboard_shortcut != NULL);
     *is_keyboard_shortcut = true;
     return false;
   }
 
   // Handle higher priority browser shortcuts such as Ctrl-w.
   Browser* browser = view() ? view()->browser() : NULL;
   if (browser)
     return browser->PreHandleKeyboardEvent(source, event, is_keyboard_shortcut);
 
   *is_keyboard_shortcut = false;
   return false;
 }
 
 void ExtensionHost::HandleKeyboardEvent(WebContents* source,
                                         const NativeWebKeyboardEvent& event) {
-  if (extension_host_type_ == chrome::VIEW_TYPE_EXTENSION_POPUP) {
+  if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP) {
     if (event.type == NativeWebKeyboardEvent::RawKeyDown &&
         event.windowsKeyCode == ui::VKEY_ESCAPE) {
       Close();
       return;
     }
   }
   UnhandledKeyboardEvent(source, event);
 }
 
 bool ExtensionHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionHost, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_EventAck, OnEventAck)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_IncrementLazyKeepaliveCount,
                         OnIncrementLazyKeepaliveCount)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_DecrementLazyKeepaliveCount,
                         OnDecrementLazyKeepaliveCount)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionHost::OnRequest(const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_.Dispatch(params, render_view_host());
 }
 
 void ExtensionHost::OnEventAck() {
-  extensions::EventRouter* router =
-      ExtensionSystem::Get(profile_)->event_router();
+  EventRouter* router = ExtensionSystem::Get(profile_)->event_router();
   if (router)
     router->OnEventAck(profile_, extension_id());
 }
 
 void ExtensionHost::OnIncrementLazyKeepaliveCount() {
   ExtensionProcessManager* pm =
       ExtensionSystem::Get(profile_)->process_manager();
   if (pm)
     pm->IncrementLazyKeepaliveCount(extension());
 }
@@ skipping 25 matching lines @@
 }
 
 void ExtensionHost::RenderViewCreated(RenderViewHost* render_view_host) {
   render_view_host_ = render_view_host;
 
   if (view())
     view()->RenderViewCreated();
 
   // If the host is bound to a window, then extract its id. Extensions hosted
   // in ExternalTabContainer objects may not have an associated window.
-  extensions::WindowController* window = GetExtensionWindowController();
+  WindowController* window = GetExtensionWindowController();
   if (window) {
     render_view_host->Send(new ExtensionMsg_UpdateBrowserWindowId(
         render_view_host->GetRoutingID(), window->GetWindowId()));
   }
 }
 
 void ExtensionHost::RenderViewDeleted(RenderViewHost* render_view_host) {
   // If our RenderViewHost is deleted, fall back to the host_contents' current
   // RVH. There is sometimes a small gap between the pending RVH being deleted
   // and RenderViewCreated being called, so we update it here.
@@ skipping 64 matching lines @@
       content::IsAudioMediaType(request.audio_type),
       content::IsVideoMediaType(request.video_type),
       &devices);
 
   // For tab capture device, we require the tabCapture permission.
   RequestMediaAccessPermissionHelper::AuthorizeRequest(
       devices, request, callback, extension(), false);
 }
 
 }  // namespace extensions