Simplfy Pepepr2 bolierplate code.

webkit/glue/plugins/pepper_device_context_2d.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_device_context_2d.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "gfx/point.h"
 #include "gfx/rect.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/ppapi/c/pp_errors.h"
 #include "third_party/ppapi/c/pp_module.h"
 #include "third_party/ppapi/c/pp_rect.h"
 #include "third_party/ppapi/c/pp_resource.h"
 #include "third_party/ppapi/c/ppb_device_context_2d.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/plugins/pepper_image_data.h"
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
-#include "webkit/glue/plugins/pepper_resource_tracker.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac_util.h"
 #include "base/scoped_cftyperef.h"
 #endif
 
 namespace pepper {
 
 namespace {
 
@@ skipping 36 matching lines @@
 
   scoped_refptr<DeviceContext2D> context(new DeviceContext2D(module));
   if (!context->Init(width, height, is_always_opaque))
     return NULL;
   context->AddRef();  // AddRef for the caller.
   return context->GetResource();
 }
 
 bool IsDeviceContext2D(PP_Resource resource) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(resource));
+      Resource::GetAs<DeviceContext2D>(resource));
   return !!context.get();
 }
 
 bool Describe(PP_Resource device_context,
               int32_t* width, int32_t* height, bool* is_always_opaque) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(device_context));
+      Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
   return context->Describe(width, height, is_always_opaque);
 }
 
 bool PaintImageData(PP_Resource device_context,
                     PP_Resource image,
                     int32_t x, int32_t y,
                     const PP_Rect* src_rect) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(device_context));
+      Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
   return context->PaintImageData(image, x, y, src_rect);
 }
 
 bool Scroll(PP_Resource device_context,
             const PP_Rect* clip_rect,
             int32_t dx, int32_t dy) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(device_context));
+      Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
   return context->Scroll(clip_rect, dx, dy);
 }
 
 bool ReplaceContents(PP_Resource device_context, PP_Resource image) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(device_context));
+      Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
   return context->ReplaceContents(image);
 }
 
 int32_t Flush(PP_Resource device_context,
               PP_CompletionCallback callback) {
   scoped_refptr<DeviceContext2D> context(
-      ResourceTracker::Get()->GetAsDeviceContext2D(device_context));
+      Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return PP_Error_BadResource;
   return context->Flush(callback);
 }
 
 const PPB_DeviceContext2D ppb_devicecontext2d = {
   &Create,
   &IsDeviceContext2D,
   &Describe,
   &PaintImageData,
@@ skipping 65 matching lines @@
                                bool* is_always_opaque) {
   *width = image_data_->width();
   *height = image_data_->height();
   *is_always_opaque = false;  // TODO(brettw) implement this.
   return true;
 }
 
 bool DeviceContext2D::PaintImageData(PP_Resource image,
                                      int32_t x, int32_t y,
                                      const PP_Rect* src_rect) {
-  scoped_refptr<ImageData> image_resource(
-      ResourceTracker::Get()->GetAsImageData(image));
+  scoped_refptr<ImageData> image_resource(Resource::GetAs<ImageData>(image));
   if (!image_resource.get())
     return false;
 
   QueuedOperation operation(QueuedOperation::PAINT);
   operation.paint_image = image_resource;
   if (!ValidateAndConvertRect(src_rect, image_resource->width(),
                               image_resource->height(),
                               &operation.paint_src_rect))
     return false;
 
@@ skipping 31 matching lines @@
     return true;
 
   operation.scroll_dx = dx;
   operation.scroll_dy = dy;
 
   queued_operations_.push_back(operation);
   return false;
 }
 
 bool DeviceContext2D::ReplaceContents(PP_Resource image) {
-  scoped_refptr<ImageData> image_resource(
-      ResourceTracker::Get()->GetAsImageData(image));
+  scoped_refptr<ImageData> image_resource(Resource::GetAs<ImageData>(image));
   if (!image_resource.get())
     return false;
   if (image_resource->format() != PP_IMAGEDATAFORMAT_BGRA_PREMUL)
     return false;
 
   if (image_resource->width() != image_data_->width() ||
       image_resource->height() != image_data_->height())
     return false;
 
   QueuedOperation operation(QueuedOperation::REPLACE);
@@ skipping 52 matching lines @@
   } else {
     // There's nothing visible to invalidate so just schedule the callback to
     // execute in the next round of the message loop.
     ScheduleOffscreenCallback(FlushCallbackData(callback));
   }
   return PP_Error_WouldBlock;
 }
 
 bool DeviceContext2D::ReadImageData(PP_Resource image, int32_t x, int32_t y) {
   // Get and validate the image object to paint into.
-  scoped_refptr<ImageData> image_resource(
-      ResourceTracker::Get()->GetAsImageData(image));
+  scoped_refptr<ImageData> image_resource(Resource::GetAs<ImageData>(image));
   if (!image_resource.get())
     return false;
   if (image_resource->format() != PP_IMAGEDATAFORMAT_BGRA_PREMUL)
     return false;  // Must be in the right format.
 
   // Validate the bitmap position.
   if (x < 0 ||
       static_cast<int64>(x) + static_cast<int64>(image_resource->width()) >
       image_data_->width())
     return false;
@@ skipping 187 matching lines @@
   data.Execute(PP_OK);
 }
 
 bool DeviceContext2D::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace pepper