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
+  gfx::Transform transform;
 };
 
 // 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 248 matching lines @@
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
   return PP_OK;
 }
 
 int32_t PepperGraphics2DHost::OnHostMsgFlush(
     ppapi::host::HostMessageContext* context) {
   // Don't allow more than one pending flush at a time.
   if (HasPendingFlush())
     return PP_ERROR_INPROGRESS;

[wjmaclean, 2016/04/13 14:47:18]

Please restore the blank line below.

[alessandroa, 2016/04/21 15:39:20]

Done.

-
   PP_Resource old_image_data = 0;
   flush_reply_context_ = context->MakeReplyMessageContext();
   if (is_running_in_process_)
     return Flush(NULL);
 
-  // Reuse image data when running out of process.

[wjmaclean, 2016/04/13 14:47:18]

Why are you deleting this comment? Doesn't it apply any longer? If so, what is
the purpose of the fluch now?

[alessandroa, 2016/04/21 15:39:20]

It was a stupid mistake :) solved. I thought it was my comment

   int32_t result = Flush(&old_image_data);
 
   if (old_image_data) {
     // If the Graphics2D has an old image data it's not using any more, send
     // it back to the plugin for possible re-use. See ppb_image_data_proxy.cc
     // for a description how this process works.
     ppapi::HostResource old_image_data_host_resource;
     old_image_data_host_resource.SetHostResource(pp_instance(), old_image_data);
     host()->Send(new PpapiMsg_PPBImageData_NotifyUnusedImageData(
         ppapi::API_ID_PPB_IMAGE_DATA, old_image_data_host_resource));
   }
 
   return result;
 }
 
 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,

[wjmaclean, 2016/04/13 14:47:18]

indenting looks wrong here ... the arguments should line up vertically

[alessandroa, 2016/04/21 15:39:20]

Done.

+            float scale,
+            const PP_Point& origin,
+            const PP_Point& transform) {

[wjmaclean, 2016/04/13 14:47:18]

'transform' seems like the wrong name here ... is this meant to be a
translation?

[alessandroa, 2016/04/21 15:39:20]

Done.

[alessandroa, 2016/04/21 15:39:20]

Done.

+  TRACE_EVENT0("pepper", "PepperGraphics2DHost::OnHostMsgSetLayerTransform");
+
+  float S = scale;
+  gfx::Point P(origin.x, origin.y);

[wjmaclean, 2016/04/13 14:47:18]

Call this 'origin' instead of 'P'

[alessandroa, 2016/04/21 15:39:20]

Done.

+  gfx::Point T(transform.x, transform.y);

[wjmaclean, 2016/04/13 14:47:18]

Call this 'translation' instead of 'T'.

[alessandroa, 2016/04/21 15:39:20]

Done.

+  gfx::Transform transform_matrix;
+
+  transform_matrix.Translate(SkFloatToScalar((1 - S) * P.x() - T.x()),

[wjmaclean, 2016/04/13 14:47:18]

Perhaps add a comment explaining in words what the transformation here
represents.

[alessandroa, 2016/04/21 15:39:20]

Done. I simplified all this part :) You will see in the next commit 

+                               SkFloatToScalar((1 - S) * P.y() - T.y()));

[wjmaclean, 2016/04/13 14:47:18]

this indentation is wrong

+  transform_matrix.Scale(S, S);
+
+  QueuedOperation operation(QueuedOperation::TRANSFORM);
+  operation.transform = transform_matrix;
+  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.transform);
+        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(gfx::Transform transform) {
+  bound_instance_->SetLayerTransform(transform);
+}
+
 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;
 
   // Portion within the source image to cut out.
   SkIRect src_irect = {src_rect.x(), src_rect.y(), src_rect.right(),
                        src_rect.bottom()};
 
   // Location within the backing store to copy to.
   *invalidated_rect = src_rect;
   invalidated_rect->Offset(x, y);
   SkRect dest_rect = {SkIntToScalar(invalidated_rect->x()),
                       SkIntToScalar(invalidated_rect->y()),
                       SkIntToScalar(invalidated_rect->right()),
                       SkIntToScalar(invalidated_rect->bottom())};
 
   if (image->format() != image_data_->format()) {
     // Convert the image data if the format does not match.
     ConvertImageData(image, src_irect, image_data_.get(), dest_rect);
   } else {
     // We're guaranteed to have a mapped canvas since we mapped it in Init().
     SkCanvas* backing_canvas = image_data_->GetCanvas();
-

[wjmaclean, 2016/04/13 14:47:18]

please restore this blank line.

[alessandroa, 2016/04/21 15:39:20]

Done.

     // We want to replace the contents of the bitmap rather than blend.
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     backing_canvas->drawBitmapRect(
         *image->GetMappedBitmap(), src_irect, dest_rect, &paint);
   }
 }
 
 void PepperGraphics2DHost::ExecuteScroll(const gfx::Rect& clip,
                                          int dx,
@@ skipping 79 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ScaleToFlooredPoint(*delta, inverse_scale);
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content