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

webkit/plugins/ppapi/ppb_graphics_2d_impl.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/ppb_graphics_2d_impl.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "skia/ext/platform_canvas.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/cpp/common.h"
+#include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/blit.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #endif
 
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_ImageData_API;
+
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 // Converts a rect inside an image of the given dimensions. The rect may be
 // NULL to indicate it should be the entire image. If the rect is outside of
 // the image, this will do nothing and return false.
 bool ValidateAndConvertRect(const PP_Rect* rect,
                             int image_width, int image_height,
@@ skipping 150 matching lines @@
   *is_always_opaque = pp::BoolToPPBool(is_always_opaque_);
   return PP_TRUE;
 }
 
 void PPB_Graphics2D_Impl::PaintImageData(PP_Resource image_data,
                                          const PP_Point* top_left,
                                          const PP_Rect* src_rect) {
   if (!top_left)
     return;
 
-  scoped_refptr<PPB_ImageData_Impl> image_resource(
-      Resource::GetAs<PPB_ImageData_Impl>(image_data));
-  if (!image_resource)
+  EnterResourceNoLock<PPB_ImageData_API> enter(image_data, true);
+  if (enter.failed())
     return;
+  PPB_ImageData_Impl* image_resource =
+      static_cast<PPB_ImageData_Impl*>(enter.object());
 
   QueuedOperation operation(QueuedOperation::PAINT);
   operation.paint_image = image_resource;
   if (!ValidateAndConvertRect(src_rect, image_resource->width(),
                               image_resource->height(),
                               &operation.paint_src_rect))
     return;
 
   // Validate the bitmap position using the previously-validated rect, there
   // should be no painted area outside of the image.
@@ skipping 30 matching lines @@
       dy <= -image_data_->height() || dy >= image_data_->height())
     return;
 
   operation.scroll_dx = dx;
   operation.scroll_dy = dy;
 
   queued_operations_.push_back(operation);
 }
 
 void PPB_Graphics2D_Impl::ReplaceContents(PP_Resource image_data) {
-  scoped_refptr<PPB_ImageData_Impl> image_resource(
-      Resource::GetAs<PPB_ImageData_Impl>(image_data));
-  if (!image_resource)
+  EnterResourceNoLock<PPB_ImageData_API> enter(image_data, true);
+  if (enter.failed())
     return;
+  PPB_ImageData_Impl* image_resource =
+      static_cast<PPB_ImageData_Impl*>(enter.object());
+
   if (!PPB_ImageData_Impl::IsImageDataFormatSupported(
           image_resource->format()))
     return;
 
   if (image_resource->width() != image_data_->width() ||
       image_resource->height() != image_data_->height())
     return;
 
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
@@ skipping 58 matching lines @@
     ScheduleOffscreenCallback(FlushCallbackData(callback));
   } else {
     unpainted_flush_callback_.Set(callback);
   }
   return PP_OK_COMPLETIONPENDING;
 }
 
 bool PPB_Graphics2D_Impl::ReadImageData(PP_Resource image,
                                         const PP_Point* top_left) {
   // Get and validate the image object to paint into.
-  scoped_refptr<PPB_ImageData_Impl> image_resource(
-      Resource::GetAs<PPB_ImageData_Impl>(image));
-  if (!image_resource)
+  EnterResourceNoLock<PPB_ImageData_API> enter(image, true);
+  if (enter.failed())
     return false;
+  PPB_ImageData_Impl* image_resource =
+      static_cast<PPB_ImageData_Impl*>(enter.object());
   if (!PPB_ImageData_Impl::IsImageDataFormatSupported(
           image_resource->format()))
     return false;  // Must be in the right format.
 
   // Validate the bitmap position.
   int x = top_left->x;
   if (x < 0 ||
       static_cast<int64>(x) + static_cast<int64>(image_resource->width()) >
       image_data_->width())
     return false;
@@ skipping 10 matching lines @@
   SkIRect src_irect = { x, y,
                         x + image_resource->width(),
                         y + image_resource->height() };
   SkRect dest_rect = { SkIntToScalar(0),
                        SkIntToScalar(0),
                        SkIntToScalar(image_resource->width()),
                        SkIntToScalar(image_resource->height()) };
 
   if (image_resource->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
-    ConvertImageData(image_data_, src_irect, image_resource.get(), dest_rect);
+    ConvertImageData(image_data_, src_irect, image_resource, dest_rect);
   } else {
     skia::PlatformCanvas* dest_canvas = image_resource->mapped_canvas();
 
     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     dest_canvas->drawBitmapRect(*image_data_->GetMappedBitmap(),
                                 &src_irect, dest_rect, &paint);
   }
   return true;
@@ skipping 224 matching lines @@
 }
 
 bool PPB_Graphics2D_Impl::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace ppapi
 }  // namespace webkit