A few more cleanups to the pepper code. Dispatch IPCs in the sockets implementations directly by ha…

content/renderer/pepper/ppb_graphics_3d_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/ppb_graphics_3d_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_platform_context_3d.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
-#include "content/renderer/pepper/resource_helper.h"
 #include "content/renderer/render_view_impl.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/ppp_graphics_3d.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
@@ skipping 173 matching lines @@
     gles2_impl()->SwapBuffers();
 
   if (bound_to_instance_) {
     // If we are bound to the instance, we need to ask the compositor
     // to commit our backing texture so that the graphics appears on the page.
     // When the backing texture will be committed we get notified via
     // ViewFlushedPaint().
     //
     // Don't need to check for NULL from GetPluginInstance since when we're
     // bound, we know our instance is valid.
-    ResourceHelper::GetPluginInstance(this)->CommitBackingTexture();
+    HostGlobals::Get()->GetInstance(pp_instance())->CommitBackingTexture();
     commit_pending_ = true;
   } else {
     // Wait for the command to complete on the GPU to allow for throttling.
     platform_context_->Echo(base::Bind(&PPB_Graphics3D_Impl::OnSwapBuffers,
                                        weak_ptr_factory_.GetWeakPtr()));
   }
 
 
   return PP_OK_COMPLETIONPENDING;
 }
@@ skipping 13 matching lines @@
         static_cast<PPB_Graphics3D_Shared*>(share_context)->gles2_impl();
   }
 
   return CreateGLES2Impl(kCommandBufferSize, kTransferBufferSize,
                          share_gles2);
 }
 
 bool PPB_Graphics3D_Impl::InitRaw(PPB_Graphics3D_API* share_context,
                                   const int32_t* attrib_list) {
   PepperPluginInstanceImpl* plugin_instance =
-      ResourceHelper::GetPluginInstance(this);
+      HostGlobals::Get()->GetInstance(pp_instance());
   if (!plugin_instance)
     return false;
 
   PlatformContext3D* share_platform_context = NULL;
   if (share_context) {
     PPB_Graphics3D_Impl* share_graphics =
         static_cast<PPB_Graphics3D_Impl*>(share_context);
     share_platform_context = share_graphics->platform_context();
   }
 
@@ skipping 20 matching lines @@
       base::Bind(&PPB_Graphics3D_Impl::OnConsoleMessage,
                  weak_ptr_factory_.GetWeakPtr()));
   return true;
 }
 
 void PPB_Graphics3D_Impl::OnConsoleMessage(const std::string& message,
                                            int id) {
   if (!bound_to_instance_)
     return;
   WebPluginContainer* container =
-      ResourceHelper::GetPluginInstance(this)->container();
+      HostGlobals::Get()->GetInstance(pp_instance())->container();
   if (!container)
     return;
   WebFrame* frame = container->element().document().frame();
   if (!frame)
     return;
   WebConsoleMessage console_message = WebConsoleMessage(
       WebConsoleMessage::LevelError, WebString(UTF8ToUTF16(message)));
   frame->addMessageToConsole(console_message);
 }
 
 void PPB_Graphics3D_Impl::OnSwapBuffers() {
   if (HasPendingSwap()) {
     // If we're off-screen, no need to trigger and wait for compositing.
     // Just send the swap-buffers ACK to the plugin immediately.
     commit_pending_ = false;
     SwapBuffersACK(PP_OK);
   }
 }
 
 void PPB_Graphics3D_Impl::OnContextLost() {
   // Don't need to check for NULL from GetPluginInstance since when we're
   // bound, we know our instance is valid.
-  if (bound_to_instance_)
-    ResourceHelper::GetPluginInstance(this)->BindGraphics(pp_instance(), 0);
+  if (bound_to_instance_) {
+    HostGlobals::Get()->GetInstance(pp_instance())->BindGraphics(
+        pp_instance(), 0);
+  }
 
   // Send context lost to plugin. This may have been caused by a PPAPI call, so
   // avoid re-entering.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PPB_Graphics3D_Impl::SendContextLost,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PPB_Graphics3D_Impl::SendContextLost() {
   // By the time we run this, the instance may have been deleted, or in the
   // process of being deleted. Even in the latter case, we don't want to send a
   // callback after DidDestroy.
-  PepperPluginInstanceImpl* instance = ResourceHelper::GetPluginInstance(this);
+  PepperPluginInstanceImpl* instance =
+      HostGlobals::Get()->GetInstance(pp_instance());
   if (!instance || !instance->container())
     return;
 
   // This PPB_Graphics3D_Impl could be deleted during the call to
   // GetPluginInterface (which sends a sync message in some cases). We still
   // send the Graphics3DContextLost to the plugin; the instance may care about
   // that event even though this context has been destroyed.
   PP_Instance this_pp_instance = pp_instance();
   const PPP_Graphics3D* ppp_graphics_3d =
       static_cast<const PPP_Graphics3D*>(
           instance->module()->GetPluginInterface(
               PPP_GRAPHICS_3D_INTERFACE));
   if (ppp_graphics_3d)
     ppp_graphics_3d->Graphics3DContextLost(this_pp_instance);
 }
 
 }  // namespace content