Update Chrome to pull latest PPAPI with new uses of point and size....

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"
@@ skipping 44 matching lines @@
         static_cast<int64>(rect->size.height) >
         static_cast<int64>(image_height))
       return false;
 
     *dest = gfx::Rect(rect->point.x, rect->point.y,
                       rect->size.width, rect->size.height);
   }
   return true;
 }
 
-PP_Resource Create(PP_Module module_id, int32_t width, int32_t height,
+PP_Resource Create(PP_Module module_id,
+                   const PP_Size* size,
                    bool is_always_opaque) {
   PluginModule* module = PluginModule::FromPPModule(module_id);
   if (!module)
     return NULL;
 
   scoped_refptr<DeviceContext2D> context(new DeviceContext2D(module));
-  if (!context->Init(width, height, is_always_opaque))
+  if (!context->Init(size->width, size->height, is_always_opaque))
     return NULL;
   context->AddRef();  // AddRef for the caller.
   return context->GetResource();
 }
 
 bool IsDeviceContext2D(PP_Resource resource) {
   scoped_refptr<DeviceContext2D> context(
       Resource::GetAs<DeviceContext2D>(resource));
   return !!context.get();
 }
 
 bool Describe(PP_Resource device_context,
-              int32_t* width, int32_t* height, bool* is_always_opaque) {
+              PP_Size* size,
+              bool* is_always_opaque) {
   scoped_refptr<DeviceContext2D> context(
       Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
-  return context->Describe(width, height, is_always_opaque);
+  return context->Describe(size, is_always_opaque);
 }
 
 bool PaintImageData(PP_Resource device_context,
                     PP_Resource image,
-                    int32_t x, int32_t y,
+                    const PP_Point* top_left,
                     const PP_Rect* src_rect) {
   scoped_refptr<DeviceContext2D> context(
       Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
-  return context->PaintImageData(image, x, y, src_rect);
+  return context->PaintImageData(image, top_left, src_rect);
 }
 
 bool Scroll(PP_Resource device_context,
             const PP_Rect* clip_rect,
-            int32_t dx, int32_t dy) {
+            const PP_Point* amount) {
   scoped_refptr<DeviceContext2D> context(
       Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
     return false;
-  return context->Scroll(clip_rect, dx, dy);
+  return context->Scroll(clip_rect, amount);
 }
 
 bool ReplaceContents(PP_Resource device_context, PP_Resource image) {
   scoped_refptr<DeviceContext2D> 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(
       Resource::GetAs<DeviceContext2D>(device_context));
   if (!context.get())
-    return PP_Error_BadResource;
+    return PP_ERROR_BADRESOURCE;
   return context->Flush(callback);
 }
 
 const PPB_DeviceContext2D ppb_devicecontext2d = {
   &Create,
   &IsDeviceContext2D,
   &Describe,
   &PaintImageData,
   &Scroll,
   &ReplaceContents,
@@ skipping 52 matching lines @@
   image_data_ = new ImageData(module());
   if (!image_data_->Init(PP_IMAGEDATAFORMAT_BGRA_PREMUL, width, height, true) ||
       !image_data_->Map()) {
     image_data_ = NULL;
     return false;
   }
 
   return true;
 }
 
-bool DeviceContext2D::Describe(int32_t* width, int32_t* height,
-                               bool* is_always_opaque) {
-  *width = image_data_->width();
-  *height = image_data_->height();
+bool DeviceContext2D::Describe(PP_Size* size, bool* is_always_opaque) {
+  if (!size || !is_always_opaque)
+    return false;
+
+  size->width = image_data_->width();
+  size->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_Point* top_left,
                                      const PP_Rect* src_rect) {
+  if (!top_left)
+    return false;
+
   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;
 
   // Validate the bitmap position using the previously-validated rect, there
   // should be no painted area outside of the image.
-  int64 x64 = static_cast<int64>(x), y64 = static_cast<int64>(y);
+  int64 x64 = static_cast<int64>(top_left->x);
+  int64 y64 = static_cast<int64>(top_left->y);
   if (x64 + static_cast<int64>(operation.paint_src_rect.x()) < 0 ||
       x64 + static_cast<int64>(operation.paint_src_rect.right()) >
       image_data_->width())
     return false;
   if (y64 + static_cast<int64>(operation.paint_src_rect.y()) < 0 ||
       y64 + static_cast<int64>(operation.paint_src_rect.bottom()) >
       image_data_->height())
     return false;
-  operation.paint_x = x;
-  operation.paint_y = y;
+  operation.paint_x = top_left->x;
+  operation.paint_y = top_left->y;
 
   queued_operations_.push_back(operation);
   return true;
 }
 
 bool DeviceContext2D::Scroll(const PP_Rect* clip_rect,
-                             int32_t dx, int32_t dy) {
+                             const PP_Point* amount) {
+  if (!amount)
+    return false;
   QueuedOperation operation(QueuedOperation::SCROLL);
   if (!ValidateAndConvertRect(clip_rect,
                               image_data_->width(),
                               image_data_->height(),
                               &operation.scroll_clip_rect))
     return false;
 
   // If we're being asked to scroll by more than the clip rect size, just
   // ignore this scroll command and say it worked.
+  int32 dx = amount->x;
+  int32 dy = amount->y;
   if (dx <= -image_data_->width() || dx >= image_data_->width() ||
       dx <= -image_data_->height() || dy >= image_data_->height())
     return true;
 
   operation.scroll_dx = dx;
   operation.scroll_dy = dy;
 
   queued_operations_.push_back(operation);
   return false;
 }
@@ skipping 12 matching lines @@
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
 
   return true;
 }
 
 int32_t DeviceContext2D::Flush(const PP_CompletionCallback& callback) {
   // Don't allow more than one pending flush at a time.
   if (HasPendingFlush())
-    return PP_Error_InProgress;
+    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;
+    return PP_ERROR_BADARGUMENT;
 
   gfx::Rect changed_rect;
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
       case QueuedOperation::PAINT:
         ExecutePaintImageData(operation.paint_image.get(),
                               operation.paint_x, operation.paint_y,
                               operation.paint_src_rect,
@@ skipping 22 matching lines @@
     visible_changed_rect = bound_instance_->clip().Intersect(changed_rect);
 
   if (bound_instance_ && !visible_changed_rect.IsEmpty()) {
     unpainted_flush_callback_.Set(callback);
     bound_instance_->InvalidateRect(visible_changed_rect);
   } 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;
+  return PP_ERROR_WOULDBLOCK;
 }
 
-bool DeviceContext2D::ReadImageData(PP_Resource image, int32_t x, int32_t y) {
+bool DeviceContext2D::ReadImageData(PP_Resource image,
+                                    const PP_Point* top_left) {
   // Get and validate the image object to paint into.
   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 (!top_left)
+    return false;
+  int x = top_left->x;
   if (x < 0 ||
       static_cast<int64>(x) + static_cast<int64>(image_resource->width()) >
       image_data_->width())
     return false;
+  int y = top_left->y;
   if (y < 0 ||
       static_cast<int64>(y) + static_cast<int64>(image_resource->height()) >
       image_data_->height())
     return false;
 
   ImageDataAutoMapper auto_mapper(image_resource.get());
   if (!auto_mapper.is_valid())
     return false;
   skia::PlatformCanvas* dest_canvas = image_resource->mapped_canvas();
 
@@ skipping 177 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