Put the Pepper stuff in the content namespace.

content/renderer/pepper/pepper_plugin_delegate_impl.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 "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 73 matching lines @@
 #include "webkit/plugins/ppapi/ppb_flash_impl.h"
 #include "webkit/plugins/ppapi/ppb_tcp_server_socket_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_tcp_socket_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_udp_socket_private_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 #include "webkit/plugins/webplugininfo.h"
 
 using WebKit::WebView;
 using WebKit::WebFrame;
 
+namespace content {
+
 namespace {
 
 class HostDispatcherWrapper
     : public webkit::ppapi::PluginDelegate::OutOfProcessProxy {
  public:
   HostDispatcherWrapper() {}
   virtual ~HostDispatcherWrapper() {}
 
   bool Init(base::ProcessHandle plugin_process_handle,
             const IPC::ChannelHandle& channel_handle,
@@ skipping 78 matching lines @@
     return true;
   }
 
  private:
   webkit::ppapi::PluginInstance* plugin_;
 };
 
 }  // namespace
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderViewImpl* render_view)
-    : content::RenderViewObserver(render_view),
+    : RenderViewObserver(render_view),
       render_view_(render_view),
       has_saved_context_menu_action_(false),
       saved_context_menu_action_(0),
       focused_plugin_(NULL),
       last_mouse_event_target_(NULL),
       device_enumeration_event_handler_(
           new PepperDeviceEnumerationEventHandler()) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
   DCHECK(mouse_lock_instances_.empty());
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
   *pepper_plugin_was_registered = true;
 
   // See if a module has already been loaded for this plugin.
   FilePath path(webplugin_info.path);
   scoped_refptr<webkit::ppapi::PluginModule> module =
       PepperPluginRegistry::GetInstance()->GetLiveModule(path);
   if (module)
     return module;
 
   // In-process plugins will have always been created up-front to avoid the
   // sandbox restrictions. So getting here implies it doesn't exist or should
   // be out of process.
-  const content::PepperPluginInfo* info =
+  const PepperPluginInfo* info =
       PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
   if (!info) {
     *pepper_plugin_was_registered = false;
     return scoped_refptr<webkit::ppapi::PluginModule>();
   } else if (!info->is_out_of_process) {
     // In-process plugin not preloaded, it probably couldn't be initialized.
     return scoped_refptr<webkit::ppapi::PluginModule>();
   }
 
   // Out of process: have the browser start the plugin process for us.
@@ skipping 296 matching lines @@
   active_instances_.erase(instance);
   UnSetAndDeleteLockTargetAdapter(instance);
 
   if (last_mouse_event_target_ == instance)
     last_mouse_event_target_ = NULL;
   if (focused_plugin_ == instance)
     PluginFocusChanged(instance, false);
 }
 
 SkBitmap* PepperPluginDelegateImpl::GetSadPluginBitmap() {
-  return content::GetContentClient()->renderer()->GetSadPluginBitmap();
+  return GetContentClient()->renderer()->GetSadPluginBitmap();
 }
 
 webkit::ppapi::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   return PepperPlatformImage2DImpl::Create(width, height);
 }
 
 webkit::ppapi::PluginDelegate::PlatformContext3D*
     PepperPluginDelegateImpl::CreateContext3D() {
 #ifdef ENABLE_GPU
@@ skipping 534 matching lines @@
   }
 }
 
 void PepperPluginDelegateImpl::UnregisterHostResolver(uint32 host_resolver_id) {
   host_resolvers_.Remove(host_resolver_id);
 }
 
 bool PepperPluginDelegateImpl::AddNetworkListObserver(
     webkit_glue::NetworkListObserver* observer) {
 #if defined(ENABLE_P2P_APIS)
-  content::P2PSocketDispatcher* socket_dispatcher =
+  P2PSocketDispatcher* socket_dispatcher =
       render_view_->p2p_socket_dispatcher();
   if (!socket_dispatcher) {
     return false;
   }
   socket_dispatcher->AddNetworkListObserver(observer);
   return true;
 #else
   return false;
 #endif
 }
 
 void PepperPluginDelegateImpl::RemoveNetworkListObserver(
     webkit_glue::NetworkListObserver* observer) {
 #if defined(ENABLE_P2P_APIS)
-  content::P2PSocketDispatcher* socket_dispatcher =
+  P2PSocketDispatcher* socket_dispatcher =
       render_view_->p2p_socket_dispatcher();
   if (socket_dispatcher)
     socket_dispatcher->RemoveNetworkListObserver(observer);
 #endif
 }
 
 int32_t PepperPluginDelegateImpl::ShowContextMenu(
     webkit::ppapi::PluginInstance* instance,
     webkit::ppapi::PPB_Flash_Menu_Impl* menu,
     const gfx::Point& position) {
   int32 render_widget_id = render_view_->routing_id();
   if (instance->FlashIsFullscreen(instance->pp_instance())) {
     webkit::ppapi::FullscreenContainer* container =
         instance->fullscreen_container();
     DCHECK(container);
     render_widget_id =
         static_cast<RenderWidgetFullscreenPepper*>(container)->routing_id();
   }
 
   int request_id = pending_context_menus_.Add(
       new scoped_refptr<webkit::ppapi::PPB_Flash_Menu_Impl>(menu));
 
-  content::ContextMenuParams params;
+  ContextMenuParams params;
   params.x = position.x();
   params.y = position.y();
   params.custom_context.is_pepper_menu = true;
   params.custom_context.request_id = request_id;
   params.custom_context.render_widget_id = render_widget_id;
   params.custom_items = menu->menu_data();
 
   // Transform the position to be in render view's coordinates.
   if (instance->view_data().is_fullscreen ||
       instance->FlashIsFullscreen(instance->pp_instance())) {
     WebKit::WebRect rect = render_view_->windowRect();
     params.x -= rect.x;
     params.y -= rect.y;
   } else {
     params.x += instance->view_data().rect.point.x;
     params.y += instance->view_data().rect.point.y;
   }
 
   IPC::Message* msg = new ViewHostMsg_ContextMenu(render_view_->routing_id(),
                                                   params);
   if (!render_view_->Send(msg)) {
     pending_context_menus_.Remove(request_id);
     return PP_ERROR_FAILED;
   }
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperPluginDelegateImpl::OnContextMenuClosed(
-    const content::CustomContextMenuContext& custom_context) {
+    const CustomContextMenuContext& custom_context) {
   int request_id = custom_context.request_id;
   scoped_refptr<webkit::ppapi::PPB_Flash_Menu_Impl>* menu_ptr =
       pending_context_menus_.Lookup(request_id);
   if (!menu_ptr) {
     NOTREACHED() << "CompleteShowContextMenu() called twice for the same menu.";
     return;
   }
   scoped_refptr<webkit::ppapi::PPB_Flash_Menu_Impl> menu = *menu_ptr;
   DCHECK(menu.get());
   pending_context_menus_.Remove(request_id);
 
   if (has_saved_context_menu_action_) {
     menu->CompleteShow(PP_OK, saved_context_menu_action_);
     has_saved_context_menu_action_ = false;
     saved_context_menu_action_ = 0;
   } else {
     menu->CompleteShow(PP_ERROR_USERCANCEL, 0);
   }
 }
 
 void PepperPluginDelegateImpl::OnCustomContextMenuAction(
-    const content::CustomContextMenuContext& custom_context,
+    const CustomContextMenuContext& custom_context,
     unsigned action) {
   // Just save the action.
   DCHECK(!has_saved_context_menu_action_);
   has_saved_context_menu_action_ = true;
   saved_context_menu_action_ = action;
 }
 
 webkit::ppapi::FullscreenContainer*
 PepperPluginDelegateImpl::CreateFullscreenContainer(
     webkit::ppapi::PluginInstance* instance) {
   return render_view_->CreatePepperFullscreenContainer(instance);
 }
 
 gfx::Size PepperPluginDelegateImpl::GetScreenSize() {
   WebKit::WebScreenInfo info = render_view_->screenInfo();
   return gfx::Size(info.rect.width, info.rect.height);
 }
 
 std::string PepperPluginDelegateImpl::GetDefaultEncoding() {
   // TODO(brettw) bug 56615: Somehow get the preference for the default
   // encoding here rather than using the global default for the UI language.
-  return content::GetContentClient()->renderer()->GetDefaultEncoding();
+  return GetContentClient()->renderer()->GetDefaultEncoding();
 }
 
 void PepperPluginDelegateImpl::ZoomLimitsChanged(double minimum_factor,
                                                  double maximum_factor) {
   double minimum_level = WebView::zoomFactorToZoomLevel(minimum_factor);
   double maximum_level = WebView::zoomFactorToZoomLevel(maximum_factor);
   render_view_->webview()->zoomLimitsChanged(minimum_level, maximum_level);
 }
 
 std::string PepperPluginDelegateImpl::ResolveProxy(const GURL& url) {
@@ skipping 17 matching lines @@
       render_view_->routing_id(), restrictions));
 }
 
 void PepperPluginDelegateImpl::SaveURLAs(const GURL& url) {
   render_view_->Send(new ViewHostMsg_SaveURLAs(
       render_view_->routing_id(), url));
 }
 
 webkit_glue::P2PTransport* PepperPluginDelegateImpl::CreateP2PTransport() {
 #if defined(ENABLE_P2P_APIS)
-  return new content::P2PTransportImpl(render_view_->p2p_socket_dispatcher());
+  return new P2PTransportImpl(render_view_->p2p_socket_dispatcher());
 #else
   return NULL;
 #endif
 }
 
 double PepperPluginDelegateImpl::GetLocalTimeZoneOffset(base::Time t) {
   double result = 0.0;
   render_view_->Send(new PepperMsg_GetLocalTimeZoneOffset(
       t, &result));
   return result;
@@ skipping 60 matching lines @@
     webkit::ppapi::PluginInstance* instance) {
   last_mouse_event_target_ = instance;
 }
 
 bool PepperPluginDelegateImpl::IsInFullscreenMode() {
   return render_view_->is_fullscreen();
 }
 
 void PepperPluginDelegateImpl::SampleGamepads(WebKit::WebGamepads* data) {
   if (!gamepad_shared_memory_reader_.get())
-    gamepad_shared_memory_reader_.reset(new content::GamepadSharedMemoryReader);
+    gamepad_shared_memory_reader_.reset(new GamepadSharedMemoryReader);
   gamepad_shared_memory_reader_->SampleGamepads(*data);
 }
 
 bool PepperPluginDelegateImpl::IsPageVisible() const {
   return !render_view_->is_hidden();
 }
 
 int PepperPluginDelegateImpl::EnumerateDevices(
     PP_DeviceType_Dev type,
     const EnumerateDevicesCallback& callback) {
@@ skipping 260 matching lines @@
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(target);
     delete target;
     mouse_lock_instances_.erase(it);
   }
 }
 
 webkit_glue::ClipboardClient*
     PepperPluginDelegateImpl::CreateClipboardClient() const {
   return new RendererClipboardClient;
 }
+
+}  // namespace content