Remove implicit flooring Scale() method from Point and Size.

webkit/plugins/ppapi/ppb_graphics_2d_impl.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 "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "skia/ext/platform_canvas.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/blit.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/rect_conversions.h"
+#include "ui/gfx/size_conversions.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/skia_util.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/gfx_conversion.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
@@ skipping 35 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;
 }
 
-// Scale the rectangle, taking care to round coordinates outward so a
-// rectangle scaled down then scaled back up by the inverse scale would
-// fully contain the entire area affected by the original rectangle.
-gfx::Rect ScaleRectBounds(const gfx::Rect& rect, float scale) {
-  int left = static_cast<int>(floorf(rect.x() * scale));
-  int top = static_cast<int>(floorf(rect.y() * scale));
-  int right = static_cast<int>(ceilf((rect.x() + rect.width()) * scale));
-  int bottom = static_cast<int>(ceilf((rect.y() + rect.height()) * scale));
-  return gfx::Rect(left, top, right - left, bottom - top);
-}
-
 // Converts BGRA <-> RGBA.
 void ConvertBetweenBGRAandRGBA(const uint32_t* input,
                                int pixel_length,
                                uint32_t* output) {
   for (int i = 0; i < pixel_length; i++) {
     const unsigned char* pixel_in =
         reinterpret_cast<const unsigned char*>(&input[i]);
     unsigned char* pixel_out = reinterpret_cast<unsigned char*>(&output[i]);
     pixel_out[0] = pixel_in[2];
     pixel_out[1] = pixel_in[1];
@@ skipping 465 matching lines @@
   // TODO(brettw) bug 56673: do a direct memcpy instead of going through CG
   // if the is_always_opaque_ flag is set. Must ensure bitmap is still clipped.
 
   CGContextDrawImage(canvas, bitmap_rect, image);
 #else
   gfx::Rect invalidate_rect = plugin_rect.Intersect(paint_rect);
   SkRect sk_invalidate_rect = gfx::RectToSkRect(invalidate_rect);
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->clipRect(sk_invalidate_rect);
   gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
-  gfx::Size image_size = pixel_image_size.Scale(scale_);
+  gfx::Size image_size = gfx::ToFlooredSize(pixel_image_size.Scale(scale_));
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return;
   if (plugin_instance->IsFullPagePlugin()) {
     // When we're resizing a window with a full-frame plugin, the plugin may
     // not yet have bound a new device, which will leave parts of the
     // background exposed if the window is getting larger. We want this to
     // show white (typically less jarring) rather than black or uninitialized.
     // We don't do this for non-full-frame plugins since we specifically want
@@ skipping 58 matching lines @@
 }
 
 // static
 bool PPB_Graphics2D_Impl::ConvertToLogicalPixels(float scale,
                                                  gfx::Rect* op_rect,
                                                  gfx::Point* delta) {
   if (scale == 1.0f || scale <= 0.0f)
     return true;
 
   gfx::Rect original_rect = *op_rect;
-  *op_rect = ScaleRectBounds(*op_rect, scale);
+  // Take the enclosing rectangle after scaling so a rectangle scaled down then
+  // scaled back up by the inverse scale would fully contain the entire area
+  // affected by the original rectangle.
+  *op_rect = gfx::ToEnclosingRect(op_rect->Scale(scale));
   if (delta) {
     gfx::Point original_delta = *delta;
     float inverse_scale = 1.0f / scale;
-    *delta = delta->Scale(scale);
-    if (original_rect != ScaleRectBounds(*op_rect, inverse_scale) ||
-        original_delta != delta->Scale(inverse_scale)) {
+    *delta = gfx::ToFlooredPoint(delta->Scale(scale));
+    if (original_rect != gfx::ToEnclosingRect(op_rect->Scale(inverse_scale)) ||
+        original_delta != gfx::ToFlooredPoint(delta->Scale(inverse_scale))) {
       return false;
     }
   }
 
   return true;
 }
 
 void PPB_Graphics2D_Impl::ExecutePaintImageData(PPB_ImageData_Impl* image,
                                                 int x, int y,
                                                 const gfx::Rect& src_rect,
@@ skipping 88 matching lines @@
 }
 
 bool PPB_Graphics2D_Impl::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace ppapi
 }  // namespace webkit