Switch to standard integer types in content/renderer/.

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 "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
 #include "cc/resources/shared_bitmap.h"
 #include "cc/resources/texture_mailbox.h"
 #include "content/child/child_shared_bitmap_manager.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/plugin_instance_throttler_impl.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 21 matching lines @@
 #include "base/mac/scoped_cftyperef.h"
 #endif
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_ImageData_API;
 
 namespace content {
 
 namespace {
 
-const int64 kOffscreenCallbackDelayMs = 1000 / 30;  // 30 fps
+const int64_t kOffscreenCallbackDelayMs = 1000 / 30;  // 30 fps
 
 // Converts a rect inside an image of the given dimensions. The rect may be
 // NULL to indicate it should be the entire image. If the rect is outside of
 // the image, this will do nothing and return false.
 bool ValidateAndConvertRect(const PP_Rect* rect,
                             int image_width,
                             int image_height,
                             gfx::Rect* dest) {
   if (!rect) {
     // Use the entire image area.
     *dest = gfx::Rect(0, 0, image_width, image_height);
   } else {
     // Validate the passed-in area.
     if (rect->point.x < 0 || rect->point.y < 0 || rect->size.width <= 0 ||
         rect->size.height <= 0)
       return false;
 
     // Check the max bounds, being careful of overflow.
-    if (static_cast<int64>(rect->point.x) +
-            static_cast<int64>(rect->size.width) >
-        static_cast<int64>(image_width))
+    if (static_cast<int64_t>(rect->point.x) +
+            static_cast<int64_t>(rect->size.width) >
+        static_cast<int64_t>(image_width))
       return false;
-    if (static_cast<int64>(rect->point.y) +
-            static_cast<int64>(rect->size.height) >
-        static_cast<int64>(image_height))
+    if (static_cast<int64_t>(rect->point.y) +
+            static_cast<int64_t>(rect->size.height) >
+        static_cast<int64_t>(image_height))
       return false;
 
     *dest = gfx::Rect(
         rect->point.x, rect->point.y, rect->size.width, rect->size.height);
   }
   return true;
 }
 
 // Converts BGRA <-> RGBA.
 void ConvertBetweenBGRAandRGBA(const uint32_t* input,
@@ skipping 158 matching lines @@
   if (enter.failed())
     return false;
   PPB_ImageData_Impl* image_resource =
       static_cast<PPB_ImageData_Impl*>(enter.object());
   if (!PPB_ImageData_Impl::IsImageDataFormatSupported(image_resource->format()))
     return false;  // Must be in the right format.
 
   // Validate the bitmap position.
   int x = top_left->x;
   if (x < 0 ||
-      static_cast<int64>(x) + static_cast<int64>(image_resource->width()) >
+      static_cast<int64_t>(x) + static_cast<int64_t>(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()) >
+      static_cast<int64_t>(y) + static_cast<int64_t>(image_resource->height()) >
           image_data_->height())
     return false;
 
   ImageDataAutoMapper auto_mapper(image_resource);
   if (!auto_mapper.is_valid())
     return false;
 
   SkIRect src_irect = {x, y, x + image_resource->width(),
                        y + image_resource->height()};
   SkRect dest_rect = {SkIntToScalar(0), SkIntToScalar(0),
@@ skipping 149 matching lines @@
   QueuedOperation operation(QueuedOperation::PAINT);
   operation.paint_image = image_resource;
   if (!ValidateAndConvertRect(src_rect_specified ? &src_rect : NULL,
                               image_resource->width(),
                               image_resource->height(),
                               &operation.paint_src_rect))
     return PP_ERROR_BADARGUMENT;
 
   // Validate the bitmap position using the previously-validated rect, there
   // should be no painted area outside of the image.
-  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()) >
+  int64_t x64 = static_cast<int64_t>(top_left.x);
+  int64_t y64 = static_cast<int64_t>(top_left.y);
+  if (x64 + static_cast<int64_t>(operation.paint_src_rect.x()) < 0 ||
+      x64 + static_cast<int64_t>(operation.paint_src_rect.right()) >
           image_data_->width())
     return PP_ERROR_BADARGUMENT;
-  if (y64 + static_cast<int64>(operation.paint_src_rect.y()) < 0 ||
-      y64 + static_cast<int64>(operation.paint_src_rect.bottom()) >
+  if (y64 + static_cast<int64_t>(operation.paint_src_rect.y()) < 0 ||
+      y64 + static_cast<int64_t>(operation.paint_src_rect.bottom()) >
           image_data_->height())
     return PP_ERROR_BADARGUMENT;
   operation.paint_x = top_left.x;
   operation.paint_y = top_left.y;
 
   queued_operations_.push_back(operation);
   return PP_OK;
 }
 
 int32_t PepperGraphics2DHost::OnHostMsgScroll(
     ppapi::host::HostMessageContext* context,
     bool clip_specified,
     const PP_Rect& clip,
     const PP_Point& amount) {
   QueuedOperation operation(QueuedOperation::SCROLL);
   if (!ValidateAndConvertRect(clip_specified ? &clip : NULL,
                               image_data_->width(),
                               image_data_->height(),
                               &operation.scroll_clip_rect))
     return PP_ERROR_BADARGUMENT;
 
   // 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;
+  int32_t dx = amount.x;
+  int32_t dy = amount.y;
   if (dx <= -image_data_->width() || dx >= image_data_->width() ||
       dy <= -image_data_->height() || dy >= image_data_->height())
     return PP_ERROR_BADARGUMENT;
 
   operation.scroll_dx = dx;
   operation.scroll_dy = dy;
 
   queued_operations_.push_back(operation);
   return PP_OK;
 }
@@ skipping 333 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ScaleToFlooredPoint(*delta, inverse_scale);
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content