ppapi/proxy/graphics_2d_resource.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/graphics_2d_resource.h"
   6
   7 #include "ppapi/c/pp_bool.h"
   8 #include "ppapi/c/pp_point.h"
   9 #include "ppapi/c/pp_rect.h"
  10 #include "ppapi/c/pp_resource.h"
  11 #include "ppapi/c/pp_size.h"
  12 #include "ppapi/c/ppb_graphics_2d.h"
  13 #include "ppapi/proxy/dispatch_reply_message.h"
  14 #include "ppapi/proxy/plugin_dispatcher.h"
  15 #include "ppapi/proxy/ppapi_messages.h"
  16 #include "ppapi/shared_impl/ppapi_globals.h"
  17 #include "ppapi/shared_impl/resource_tracker.h"
  18 #include "ppapi/shared_impl/tracked_callback.h"
  19 #include "ppapi/thunk/enter.h"
  20 #include "ppapi/thunk/ppb_image_data_api.h"
  21
  22 namespace ppapi {
  23 namespace proxy {
  24
  25 Graphics2DResource::Graphics2DResource(Connection connection,
  26                                        PP_Instance instance,
  27                                        const PP_Size& size,
  28                                        PP_Bool is_always_opaque)
  29     : PluginResource(connection, instance),
  30       size_(size),
  31       is_always_opaque_(is_always_opaque),
  32       scale_(1.0f) {
  33   // These checks are copied from PPB_ImageData_Impl::Init to make tests passed.
  34   // Let's remove/refactor this when start to refactor ImageData.
  35   bool bad_args = size.width <= 0 || size.height <= 0 ||
  36       static_cast<int64>(size.width) * static_cast<int64>(size.height) >=
  37           std::numeric_limits<int32>::max() / 4;
  38   if (!bad_args && !sent_create_to_renderer()) {
  39     SendCreate(RENDERER,
  40         PpapiHostMsg_Graphics2D_Create(size, is_always_opaque));
  41   }
  42 }
  43
  44 Graphics2DResource::~Graphics2DResource() {
  45 }
  46
  47 PP_Bool Graphics2DResource::Describe(PP_Size* size, PP_Bool* is_always_opaque) {
  48   *size = size_;
  49   *is_always_opaque = is_always_opaque_;
  50   return PP_TRUE;
  51 }
  52
  53 thunk::PPB_Graphics2D_API* Graphics2DResource::AsPPB_Graphics2D_API() {
  54   return this;
  55 }
  56
  57 void Graphics2DResource::PaintImageData(PP_Resource image_data,
  58                                         const PP_Point* top_left,
  59                                         const PP_Rect* src_rect) {
  60   Resource* image_object =
  61       PpapiGlobals::Get()->GetResourceTracker()->GetResource(image_data);
  62   if (!image_object || pp_instance() != image_object->pp_instance()) {
  63     Log(PP_LOGLEVEL_ERROR,
  64         "Graphics2DResource.PaintImageData: Bad image resource.");
  65     return;
  66   }
  67
  68   PP_Rect dummy;
  69   memset(&dummy, 0, sizeof(PP_Rect));
  70   Post(RENDERER, PpapiHostMsg_Graphics2D_PaintImageData(
  71       image_object->host_resource(), *top_left,
  72       !!src_rect, src_rect ? *src_rect : dummy));
  73 }
  74
  75 void Graphics2DResource::Scroll(const PP_Rect* clip_rect,
  76                                 const PP_Point* amount) {
  77   PP_Rect dummy;
  78   memset(&dummy, 0, sizeof(PP_Rect));
  79   Post(RENDERER, PpapiHostMsg_Graphics2D_Scroll(
  80       !!clip_rect, clip_rect ? *clip_rect : dummy, *amount));
  81 }
  82
  83 void Graphics2DResource::ReplaceContents(PP_Resource image_data) {
  84   thunk::EnterResourceNoLock<thunk::PPB_ImageData_API> enter_image(
  85       image_data, true);
  86   if (enter_image.failed())
  87     return;
  88
  89   // Check that the PP_Instance matches.
  90   Resource* image_object =
  91       PpapiGlobals::Get()->GetResourceTracker()->GetResource(image_data);
  92   if (!image_object || pp_instance() != image_object->pp_instance()) {
  93     Log(PP_LOGLEVEL_ERROR,
  94         "Graphics2DResource.PaintImageData: Bad image resource.");
  95     return;
  96   }
  97   enter_image.object()->SetIsCandidateForReuse();
  98
  99   Post(RENDERER, PpapiHostMsg_Graphics2D_ReplaceContents(
 100       image_object->host_resource()));
 101 }
 102
 103 PP_Bool Graphics2DResource::SetScale(float scale) {
 104   if (scale <= 0.0f)
 105     return PP_FALSE;
 106   Post(RENDERER, PpapiHostMsg_Graphics2D_Dev_SetScale(scale));
 107   scale_ = scale;
 108   return PP_TRUE;
 109 }
 110
 111 float Graphics2DResource::GetScale() {
 112   return scale_;
 113 }
 114
 115 void Graphics2DResource::SetOffset(const PP_Point* offset) {
 116   Post(RENDERER, PpapiHostMsg_Graphics2D_SetOffset(*offset));
 117 }
 118
 119 void Graphics2DResource::SetResizeMode(
 120     PP_Graphics2D_Dev_ResizeMode resize_mode) {
 121   Post(RENDERER, PpapiHostMsg_Graphics2D_SetResizeMode(resize_mode));
 122 }
 123
 124 int32_t Graphics2DResource::Flush(scoped_refptr<TrackedCallback> callback) {
 125   // If host is not even created, return failure immediately.  This can happen
 126   // when failed to initialize (in constructor).
 127   if (!sent_create_to_renderer())
 128     return PP_ERROR_FAILED;
 129
 130   if (TrackedCallback::IsPending(current_flush_callback_))
 131     return PP_ERROR_INPROGRESS;  // Can't have >1 flush pending.
 132   current_flush_callback_ = callback;
 133
 134   // Send the current view data with the Flush() message. This allows the
 135   // renderer to know what the plugin's view of the renderer is at the time
 136   // Flush was called.
 137   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
 138       pp_instance());
 139   ppapi::ViewData view_data;
 140   if (dispatcher) {
 141     InstanceData* data = dispatcher->GetInstanceData(pp_instance());
 142     if (data)
 143       view_data = data->view;
 144   }
 145   Call<PpapiPluginMsg_Graphics2D_FlushAck>(
 146       RENDERER,
 147       PpapiHostMsg_Graphics2D_Flush(view_data),
 148       base::Bind(&Graphics2DResource::OnPluginMsgFlushACK, this));
 149   return PP_OK_COMPLETIONPENDING;
 150 }
 151
 152 bool Graphics2DResource::ReadImageData(PP_Resource image,
 153                                        const PP_Point* top_left) {
 154   if (!top_left)
 155     return false;
 156   int32_t result = SyncCall<PpapiPluginMsg_Graphics2D_ReadImageDataAck>(
 157       RENDERER,
 158       PpapiHostMsg_Graphics2D_ReadImageData(image, *top_left));
 159   return result == PP_OK;
 160 }
 161
 162 void Graphics2DResource::OnPluginMsgFlushACK(
 163     const ResourceMessageReplyParams& params) {
 164   current_flush_callback_->Run(params.result());
 165 }
 166
 167 }  // namespace proxy
 168 }  // namespace ppapi