New thunk system for Pepper proxy and implementation

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/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"
@@ skipping 79 matching lines @@
       ConvertBetweenBGRAandRGBA(
           src_bitmap->getAddr32(static_cast<int>(src_rect.fLeft),
                                 static_cast<int>(src_rect.fTop + y)),
           src_rect.width(),
           dest_bitmap->getAddr32(static_cast<int>(dest_rect.fLeft),
                                  static_cast<int>(dest_rect.fTop + y)));
     }
   }
 }
 
-PP_Resource Create(PP_Instance instance_id,
-                   const PP_Size* size,
-                   PP_Bool is_always_opaque) {
-  PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
-  if (!instance)
-    return 0;
-
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      new PPB_Graphics2D_Impl(instance));
-  if (!context->Init(size->width, size->height, PPBoolToBool(is_always_opaque)))
-    return 0;
-  return context->GetReference();
-}
-
-PP_Bool IsGraphics2D(PP_Resource resource) {
-  return BoolToPPBool(!!Resource::GetAs<PPB_Graphics2D_Impl>(resource));
-}
-
-PP_Bool Describe(PP_Resource graphics_2d,
-                 PP_Size* size,
-                 PP_Bool* is_always_opaque) {
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_2d));
-  if (!context) {
-    *size = PP_MakeSize(0, 0);
-    *is_always_opaque = PP_FALSE;
-    return PP_FALSE;
-  }
-  return context->Describe(size, is_always_opaque);
-}
-
-void PaintImageData(PP_Resource graphics_2d,
-                    PP_Resource image_data,
-                    const PP_Point* top_left,
-                    const PP_Rect* src_rect) {
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_2d));
-  if (context)
-    context->PaintImageData(image_data, top_left, src_rect);
-}
-
-void Scroll(PP_Resource graphics_2d,
-            const PP_Rect* clip_rect,
-            const PP_Point* amount) {
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_2d));
-  if (context)
-    context->Scroll(clip_rect, amount);
-}
-
-void ReplaceContents(PP_Resource graphics_2d, PP_Resource image_data) {
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_2d));
-  if (context)
-    context->ReplaceContents(image_data);
-}
-
-int32_t Flush(PP_Resource graphics_2d,
-              PP_CompletionCallback callback) {
-  scoped_refptr<PPB_Graphics2D_Impl> context(
-      Resource::GetAs<PPB_Graphics2D_Impl>(graphics_2d));
-  if (!context)
-    return PP_ERROR_BADRESOURCE;
-  return context->Flush(callback);
-}
-
-const PPB_Graphics2D ppb_graphics_2d = {
-  &Create,
-  &IsGraphics2D,
-  &Describe,
-  &PaintImageData,
-  &Scroll,
-  &ReplaceContents,
-  &Flush
-};
-
 }  // namespace
 
 struct PPB_Graphics2D_Impl::QueuedOperation {
   enum Type {
     PAINT,
     SCROLL,
     REPLACE
   };
 
   QueuedOperation(Type t)
@@ skipping 25 matching lines @@
       flushed_any_data_(false),
       offscreen_flush_pending_(false),
       is_always_opaque_(false) {
 }
 
 PPB_Graphics2D_Impl::~PPB_Graphics2D_Impl() {
 }
 
 // static
 const PPB_Graphics2D* PPB_Graphics2D_Impl::GetInterface() {
-  return &ppb_graphics_2d;
+  return ::ppapi::thunk::GetPPB_Graphics2D_Thunk();
 }
 
 bool PPB_Graphics2D_Impl::Init(int width, int height, bool is_always_opaque) {
   // The underlying PPB_ImageData_Impl will validate the dimensions.
   image_data_ = new PPB_ImageData_Impl(instance());
   if (!image_data_->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(),
                          width, height, true) ||
       !image_data_->Map()) {
     image_data_ = NULL;
     return false;
   }
   is_always_opaque_ = is_always_opaque;
   return true;
 }
 
+::ppapi::thunk::PPB_Graphics2D_API* PPB_Graphics2D_Impl::AsGraphics2D_API() {
+  return this;
+}
+
 PPB_Graphics2D_Impl* PPB_Graphics2D_Impl::AsPPB_Graphics2D_Impl() {
   return this;
 }
 
 PP_Bool PPB_Graphics2D_Impl::Describe(PP_Size* size,
                                       PP_Bool* is_always_opaque) {
   size->width = image_data_->width();
   size->height = image_data_->height();
   *is_always_opaque = pp::BoolToPPBool(is_always_opaque_);
   return PP_TRUE;
@@ skipping 69 matching lines @@
 
   if (image_resource->width() != image_data_->width() ||
       image_resource->height() != image_data_->height())
     return;
 
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
 }
 
-int32_t PPB_Graphics2D_Impl::Flush(const PP_CompletionCallback& callback) {
+int32_t PPB_Graphics2D_Impl::Flush(PP_CompletionCallback callback) {
   // Don't allow more than one pending flush at a time.
   if (HasPendingFlush())
     return PP_ERROR_INPROGRESS;
 
   // TODO(brettw) check that the current thread is not the main one and
   // implement blocking flushes in this case.
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
 
   bool nothing_visible = true;
@@ skipping 323 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