Added SetLayerTransform to PPAPI

content/renderer/pepper/pepper_graphics_2d_host.cc

 // Copyright (c) 2012 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 "content/renderer/pepper/pepper_graphics_2d_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 112 matching lines @@
           src_bitmap->getAddr32(static_cast<int>(src_rect.fLeft),
                                 static_cast<int>(src_rect.fTop + y)),
           src_rect.width());
     }
   }
 }
 
 }  // namespace
 
 struct PepperGraphics2DHost::QueuedOperation {
-  enum Type { PAINT, SCROLL, REPLACE, };
+  enum Type { PAINT, SCROLL, REPLACE, TRANSFORM };
 
   QueuedOperation(Type t)
       : type(t), paint_x(0), paint_y(0), scroll_dx(0), scroll_dy(0) {}
 
   Type type;
 
   // Valid when type == PAINT.
   scoped_refptr<PPB_ImageData_Impl> paint_image;
   int paint_x, paint_y;
   gfx::Rect paint_src_rect;
 
   // Valid when type == SCROLL.
   gfx::Rect scroll_clip_rect;
   int scroll_dx, scroll_dy;
 
   // Valid when type == REPLACE.
   scoped_refptr<PPB_ImageData_Impl> replace_image;
+
+  // Valid when type == TRANSFORM
+  float scale;
+  gfx::PointF translation;
 };
 
 // static
 PepperGraphics2DHost* PepperGraphics2DHost::Create(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource,
     const PP_Size& size,
     PP_Bool is_always_opaque,
     scoped_refptr<PPB_ImageData_Impl> backing_store) {
@@ skipping 55 matching lines @@
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_PaintImageData,
                                       OnHostMsgPaintImageData)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_Scroll,
                                       OnHostMsgScroll)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_ReplaceContents,
                                       OnHostMsgReplaceContents)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_Graphics2D_Flush,
                                         OnHostMsgFlush)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_SetScale,
                                       OnHostMsgSetScale)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_SetLayerTransform,
+                                      OnHostMsgSetLayerTransform)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Graphics2D_ReadImageData,
                                       OnHostMsgReadImageData)
   PPAPI_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 bool PepperGraphics2DHost::IsGraphics2DHost() { return true; }
 
 bool PepperGraphics2DHost::ReadImageData(PP_Resource image,
                                          const PP_Point* top_left) {
@@ skipping 281 matching lines @@
 int32_t PepperGraphics2DHost::OnHostMsgSetScale(
     ppapi::host::HostMessageContext* context,
     float scale) {
   if (scale > 0.0f) {
     scale_ = scale;
     return PP_OK;
   }
   return PP_ERROR_BADARGUMENT;
 }
 
+int32_t PepperGraphics2DHost::OnHostMsgSetLayerTransform(
+            ppapi::host::HostMessageContext* context,
+            float scale,
+            const PP_FloatPoint& translation) {
+  if (scale < 0.0f)
+    return PP_ERROR_BADARGUMENT;
+
+  QueuedOperation operation(QueuedOperation::TRANSFORM);
+  operation.scale = scale;
+  operation.translation = gfx::PointF(translation.x, translation.y);
+  queued_operations_.push_back(operation);
+  return PP_OK;
+}
+
+
 int32_t PepperGraphics2DHost::OnHostMsgReadImageData(
     ppapi::host::HostMessageContext* context,
     PP_Resource image,
     const PP_Point& top_left) {
   context->reply_msg = PpapiPluginMsg_Graphics2D_ReadImageDataAck();
   return ReadImageData(image, &top_left) ? PP_OK : PP_ERROR_FAILED;
 }
 
 void PepperGraphics2DHost::ReleaseCallback(
     std::unique_ptr<cc::SharedBitmap> bitmap,
@@ skipping 46 matching lines @@
 }
 
 void PepperGraphics2DHost::AttachedToNewLayer() {
   texture_mailbox_modified_ = true;
 }
 
 int32_t PepperGraphics2DHost::Flush(PP_Resource* old_image_data) {
   bool done_replace_contents = false;
   bool no_update_visible = true;
   bool is_plugin_visible = true;
+
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
+      case QueuedOperation::TRANSFORM:
+        ExecuteTransform(operation.scale, operation.translation);
+        no_update_visible = false;
+        break;
       case QueuedOperation::PAINT:
         ExecutePaintImageData(operation.paint_image.get(),
                               operation.paint_x,
                               operation.paint_y,
                               operation.paint_src_rect,
                               &op_rect);
         break;
       case QueuedOperation::SCROLL:
         ExecuteScroll(operation.scroll_clip_rect,
                       operation.scroll_dx,
@@ skipping 65 matching lines @@
   }
 
   if (bound_instance_ && bound_instance_->throttler() &&
       bound_instance_->throttler()->needs_representative_keyframe()) {
     bound_instance_->throttler()->OnImageFlush(image_data_->GetMappedBitmap());
   }
 
   return PP_OK_COMPLETIONPENDING;
 }
 
+void PepperGraphics2DHost::ExecuteTransform(const float& scale,
+                                            const gfx::PointF& translate) {
+  bound_instance_->SetGraphics2DTransform(scale, translate);
+}
+
 void PepperGraphics2DHost::ExecutePaintImageData(PPB_ImageData_Impl* image,
                                                  int x,
                                                  int y,
                                                  const gfx::Rect& src_rect,
                                                  gfx::Rect* invalidated_rect) {
   // Ensure the source image is mapped to read from it.
   ImageDataAutoMapper auto_mapper(image);
   if (!auto_mapper.is_valid())
     return;
 
@@ skipping 108 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ScaleToFlooredPoint(*delta, inverse_scale);
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content