Scale to DIPs in ppb_graphics2d_impl for proper invalidation

ui/gfx/rect.h

 // 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.
 
 // Defines a simple integer rectangle class.  The containment semantics
 // are array-like; that is, the coordinate (x, y) is considered to be
 // contained by the rectangle, but the coordinate (x + width, y) is not.
 // The class will happily let you create malformed rectangles (that is,
 // rectangles with negative width and/or height), but there will be assertions
 // in the operations (such as Contains()) to complain in this case.
@@ skipping 27 matching lines @@
 #elif defined(OS_MACOSX)
   explicit Rect(const CGRect& r);
 #elif defined(TOOLKIT_GTK)
   explicit Rect(const GdkRectangle& r);
 #endif
   explicit Rect(const gfx::Size& size);
   Rect(const gfx::Point& origin, const gfx::Size& size);
 
   ~Rect();
 
+  // Apply scale to a rectangle, taking care in to round coordinates outward so
+  // a rectangle scaled down then scaled back up by the inverse scale would
+  // fully contain the original.
+  void ScaleBounds(float scale);

[sky, 2012/07/17 22:12:12]

rect_base already has Scale(float). Is there a reason that doesn't work?

[Josh Horwich, 2012/07/17 22:53:36]

Yes, that method scales the origin and size independently, and the conversion
float->int occurs with a simple static_cast<int> so it will round down. So if
scale is 0.5 (typical on a 2x density display like a Mac Retina when converting
from device pixels to logical pixels/DIPs) and the rectangle in question has
origin (9, 9) and size (10, 10) we'd want the result to be origin (4, 4) and
size (6, 6) when calculating invalid rects in the lower-res (logical pixel)
coordinate system. Using the existing Scale would result in origin (4, 4) but
size (5, 5) and we'd end up not covering the lower-right line of pixels. :(

I didn't change Scale itself in fear of opening up a few thousand cans worth of
worms.

I moved this here since I thought it might be more generally useful for others -
but I don't feel strongly that it should be here - if you wish I can move it
back into the code that specifically needs it (ppb_graphics_2d_impl.cc in my
case)

+
 #if defined(OS_WIN)
   Rect& operator=(const RECT& r);
 #elif defined(OS_MACOSX)
   Rect& operator=(const CGRect& r);
 #elif defined(TOOLKIT_GTK)
   Rect& operator=(const GdkRectangle& r);
 #endif
 
 #if defined(OS_WIN)
   // Construct an equivalent Win32 RECT object.
   RECT ToRECT() const;
 #elif defined(TOOLKIT_GTK)
   GdkRectangle ToGdkRectangle() const;
 #elif defined(OS_MACOSX)
   // Construct an equivalent CoreGraphics object.
   CGRect ToCGRect() const;
 #endif
 
   std::string ToString() const;
 };
 
 #if !defined(COMPILER_MSVC)
 extern template class RectBase<Rect, Point, Size, Insets, int>;
 #endif
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RECT_H_