Convert most remaining resources to use the API/thunk system. The significant

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 67 matching lines @@
 #if defined(OS_WIN)
 #include "skia/ext/vector_platform_device_emf_win.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/gdi_util.h"
 #endif
 
 #if defined(OS_MACOSX) && defined(USE_SKIA)
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
-using ::ppapi::thunk::EnterResourceNoLock;
-using ::ppapi::thunk::PPB_Buffer_API;
-using ::ppapi::thunk::PPB_Graphics2D_API;
-using ::ppapi::thunk::PPB_Instance_FunctionAPI;
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_Buffer_API;
+using ppapi::thunk::PPB_Graphics2D_API;
+using ppapi::thunk::PPB_ImageData_API;
+using ppapi::thunk::PPB_Instance_FunctionAPI;
+using ppapi::thunk::PPB_Surface3D_API;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebString;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
@@ skipping 291 matching lines @@
                                PP_Resource custom_image,
                                const PP_Point* hot_spot) {
   if (type != PP_CURSORTYPE_CUSTOM) {
     cursor_.reset(new WebCursorInfo(static_cast<WebCursorInfo::Type>(type)));
     return true;
   }
 
   if (!hot_spot)
     return false;
 
-  scoped_refptr<PPB_ImageData_Impl> image_data(
-      Resource::GetAs<PPB_ImageData_Impl>(custom_image));
-  if (!image_data.get())
+  EnterResourceNoLock<PPB_ImageData_API> enter(custom_image, true);
+  if (enter.failed())
     return false;
+  PPB_ImageData_Impl* image_data =
+      static_cast<PPB_ImageData_Impl*>(enter.object());
 
   if (image_data->format() != PPB_ImageData_Impl::GetNativeImageDataFormat()) {
     // TODO(yzshen): Handle the case that the image format is different from the
     // native format.
     NOTIMPLEMENTED();
     return false;
   }
 
   ImageDataAutoMapper auto_mapper(image_data);
   if (!auto_mapper.is_valid())
@@ skipping 712 matching lines @@
                       size_in_pixels.height(), true, false, true, true);
     skia::EndPlatformPaint(canvas);
   }
 #endif  // defined(OS_WIN)
 
   return ret;
 }
 
 bool PluginInstance::PrintRasterOutput(PP_Resource print_output,
                                        WebKit::WebCanvas* canvas) {
-  scoped_refptr<PPB_ImageData_Impl> image(
-      Resource::GetAs<PPB_ImageData_Impl>(print_output));
-  if (!image.get() || !image->is_mapped())
+  EnterResourceNoLock<PPB_ImageData_API> enter(print_output, true);
+  if (enter.failed())
+    return false;
+  PPB_ImageData_Impl* image =
+      static_cast<PPB_ImageData_Impl*>(enter.object());
+
+  // TODO(brettw) this should not require the image to be mapped. It should
+  // instead map on demand. The DCHECK here is to remind you if you see the
+  // assert fire, fix the bug rather than mapping the data.
+  DCHECK(image->is_mapped());
+  if (!image->is_mapped())
     return false;
 
   const SkBitmap* bitmap = image->GetMappedBitmap();
   if (!bitmap)
     return false;
 
   // Draw the printed image into the supplied canvas.
   SkIRect src_rect;
   src_rect.set(0, 0, bitmap->width(), bitmap->height());
   SkRect dest_rect;
@@ skipping 119 matching lines @@
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX) && !defined(USE_SKIA)
 
 PPB_Graphics2D_Impl* PluginInstance::bound_graphics_2d() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
-  return bound_graphics_->Cast<PPB_Graphics2D_Impl>();
+  if (bound_graphics_->AsPPB_Graphics2D_API())
+    return static_cast<PPB_Graphics2D_Impl*>(bound_graphics_.get());
+  return NULL;
 }
 
 PPB_Surface3D_Impl* PluginInstance::bound_graphics_3d() const {
   if (bound_graphics_.get() == NULL)
     return NULL;
 
-  return bound_graphics_->Cast<PPB_Surface3D_Impl>();
+  if (bound_graphics_->AsPPB_Surface3D_API())
+    return static_cast<PPB_Surface3D_Impl*>(bound_graphics_.get());
+  return NULL;
 }
 
 void PluginInstance::setBackingTextureId(unsigned int id) {
   // If we have a full-screen container_ then the plugin is fullscreen,
   // and the parent context is not the one for the browser page, but for the
   // full-screen window, and so the parent texture ID doesn't correspond to
   // anything in the page's context.
   //
   // TODO(alokp): It would be better at some point to have the equivalent
   // in the FullscreenContainer so that we don't need to poll
@@ skipping 66 matching lines @@
       setBackingTextureId(0);
       InvalidateRect(gfx::Rect());
     }
     bound_graphics_ = NULL;
     return PP_TRUE;
   }
 
   EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
   PPB_Graphics2D_Impl* graphics_2d = enter_2d.succeeded() ?
       static_cast<PPB_Graphics2D_Impl*>(enter_2d.object()) : NULL;
-  // Surface3D not converted to API yet.
-  scoped_refptr<PPB_Surface3D_Impl> graphics_3d =
-      Resource::GetAs<PPB_Surface3D_Impl>(device);
+  EnterResourceNoLock<PPB_Surface3D_API> enter_3d(device, false);
+  PPB_Surface3D_Impl* graphics_3d = enter_3d.succeeded() ?
+      static_cast<PPB_Surface3D_Impl*>(enter_3d.object()) : NULL;
 
   if (graphics_2d) {
     // Refuse to bind if we're transitioning to fullscreen.
     if (fullscreen_container_ && !fullscreen_)
       return PP_FALSE;
     if (graphics_2d->instance() != this)
       return PP_FALSE;  // Can't bind other instance's contexts.
     if (!graphics_2d->BindToInstance(this))
       return PP_FALSE;  // Can't bind to more than one instance.
 
@@ skipping 116 matching lines @@
 }
 
 PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
   gfx::Size screen_size = delegate()->GetScreenSize();
   *size = PP_MakeSize(screen_size.width(), screen_size.height());
   return PP_TRUE;
 }
 
 }  // namespace ppapi
 }  // namespace webkit