Change all uses of the RoundedRect class to use FloatRoundedRect instead.

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 12 matching lines @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/graphics/GraphicsContext.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/IntRect.h"
-#include "platform/geometry/RoundedRect.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "platform/weborigin/KURL.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkClipStack.h"
@@ skipping 654 matching lines @@
 
     if (focusRingRegion.isRect()) {
         drawFocusRingRect(SkRect::MakeFromIRect(focusRingRegion.getBounds()), color, width);
     } else {
         SkPath path;
         if (focusRingRegion.getBoundaryPath(&path))
             drawFocusRingPath(path, color, width);
     }
 }
 
-static inline IntRect areaCastingShadowInHole(const IntRect& holeRect, int shadowBlur, int shadowSpread, const IntSize& shadowOffset)
+static inline FloatRect areaCastingShadowInHole(const FloatRect& holeRect, int shadowBlur, int shadowSpread, const IntSize& shadowOffset)
 {
     IntRect bounds(holeRect);
 
     bounds.inflate(shadowBlur);
 
     if (shadowSpread < 0)
         bounds.inflate(-shadowSpread);
 
     IntRect offsetBounds = bounds;
     offsetBounds.move(-shadowOffset);
     return unionRect(bounds, offsetBounds);
 }
 
-void GraphicsContext::drawInnerShadow(const RoundedRect& rect, const Color& shadowColor, const IntSize shadowOffset, int shadowBlur, int shadowSpread, Edges clippedEdges)
+void GraphicsContext::drawInnerShadow(const FloatRoundedRect& rect, const Color& shadowColor, const IntSize shadowOffset, int shadowBlur, int shadowSpread, Edges clippedEdges)
 {
     if (contextDisabled())
         return;
 
-    IntRect holeRect(rect.rect());
+    FloatRect holeRect(rect.rect());
     holeRect.inflate(-shadowSpread);
 
     if (holeRect.isEmpty()) {
         if (rect.isRounded())
             fillRoundedRect(rect, shadowColor);
         else
             fillRect(rect.rect(), shadowColor);
         return;
     }
 
     if (clippedEdges & LeftEdge) {
         holeRect.move(-std::max(shadowOffset.width(), 0) - shadowBlur, 0);
         holeRect.setWidth(holeRect.width() + std::max(shadowOffset.width(), 0) + shadowBlur);
     }
     if (clippedEdges & TopEdge) {
         holeRect.move(0, -std::max(shadowOffset.height(), 0) - shadowBlur);
         holeRect.setHeight(holeRect.height() + std::max(shadowOffset.height(), 0) + shadowBlur);
     }
     if (clippedEdges & RightEdge)
         holeRect.setWidth(holeRect.width() - std::min(shadowOffset.width(), 0) + shadowBlur);
     if (clippedEdges & BottomEdge)
         holeRect.setHeight(holeRect.height() - std::min(shadowOffset.height(), 0) + shadowBlur);
 
     Color fillColor(shadowColor.red(), shadowColor.green(), shadowColor.blue(), 255);
 
-    IntRect outerRect = areaCastingShadowInHole(rect.rect(), shadowBlur, shadowSpread, shadowOffset);
-    RoundedRect roundedHole(holeRect, rect.radii());
+    FloatRect outerRect = areaCastingShadowInHole(rect.rect(), shadowBlur, shadowSpread, shadowOffset);
+    FloatRoundedRect roundedHole(holeRect, rect.radii());
 
     save();
     if (rect.isRounded()) {
         Path path;
         path.addRoundedRect(rect);
         clipPath(path);
         roundedHole.shrinkRadii(shadowSpread);
     } else {
         clip(rect.rect());
     }
@@ skipping 567 matching lines @@
 {
     if (contextDisabled())
         return;
 
     SkRect r = rect;
     SkPaint paint = immutableState()->fillPaint();
     paint.setColor(color.rgb());
     drawRect(r, paint);
 }
 
-void GraphicsContext::fillBetweenRoundedRects(const IntRect& outer, const IntSize& outerTopLeft, const IntSize& outerTopRight, const IntSize& outerBottomLeft, const IntSize& outerBottomRight,
-    const IntRect& inner, const IntSize& innerTopLeft, const IntSize& innerTopRight, const IntSize& innerBottomLeft, const IntSize& innerBottomRight, const Color& color)
+void GraphicsContext::fillBetweenRoundedRects(const FloatRect& outer, const FloatSize& outerTopLeft, const FloatSize& outerTopRight, const FloatSize& outerBottomLeft, const FloatSize& outerBottomRight,
+    const FloatRect& inner, const FloatSize& innerTopLeft, const FloatSize& innerTopRight, const FloatSize& innerBottomLeft, const FloatSize& innerBottomRight, const Color& color)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     SkVector outerRadii[4];
     SkVector innerRadii[4];
     setRadii(outerRadii, outerTopLeft, outerTopRight, outerBottomRight, outerBottomLeft);
     setRadii(innerRadii, innerTopLeft, innerTopRight, innerBottomRight, innerBottomLeft);
 
     SkRRect rrOuter;
     SkRRect rrInner;
     rrOuter.setRectRadii(outer, outerRadii);
     rrInner.setRectRadii(inner, innerRadii);
 
     SkPaint paint(immutableState()->fillPaint());
     paint.setColor(color.rgb());
 
     m_canvas->drawDRRect(rrOuter, rrInner, paint);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawBounded(this, rrOuter.getBounds(), paint);
 }
 
-void GraphicsContext::fillBetweenRoundedRects(const RoundedRect& outer, const RoundedRect& inner, const Color& color)
+void GraphicsContext::fillBetweenRoundedRects(const FloatRoundedRect& outer, const FloatRoundedRect& inner, const Color& color)
 {
     fillBetweenRoundedRects(outer.rect(), outer.radii().topLeft(), outer.radii().topRight(), outer.radii().bottomLeft(), outer.radii().bottomRight(),
         inner.rect(), inner.radii().topLeft(), inner.radii().topRight(), inner.radii().bottomLeft(), inner.radii().bottomRight(), color);
 }
 
-void GraphicsContext::fillRoundedRect(const IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
-    const IntSize& bottomLeft, const IntSize& bottomRight, const Color& color)
+void GraphicsContext::fillRoundedRect(const FloatRect& rect, const FloatSize& topLeft, const FloatSize& topRight,
+    const FloatSize& bottomLeft, const FloatSize& bottomRight, const Color& color)
 {
     ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     if (topLeft.width() + topRight.width() > rect.width()
             || bottomLeft.width() + bottomRight.width() > rect.width()
             || topLeft.height() + bottomLeft.height() > rect.height()
             || topRight.height() + bottomRight.height() > rect.height()) {
         // Not all the radii fit, return a rect. This matches the behavior of
@@ skipping 70 matching lines @@
 }
 
 void GraphicsContext::strokeEllipse(const FloatRect& ellipse)
 {
     if (contextDisabled())
         return;
 
     drawOval(ellipse, immutableState()->strokePaint());
 }
 
-void GraphicsContext::clipRoundedRect(const RoundedRect& rect, SkRegion::Op regionOp)
+void GraphicsContext::clipRoundedRect(const FloatRoundedRect& rect, SkRegion::Op regionOp)
 {
     if (contextDisabled())
         return;
 
     if (!rect.isRounded()) {
         clipRect(rect.rect(), NotAntiAliased, regionOp);
         return;
     }
 
     SkVector radii[4];
-    RoundedRect::Radii wkRadii = rect.radii();
+    FloatRoundedRect::Radii wkRadii = rect.radii();
     setRadii(radii, wkRadii.topLeft(), wkRadii.topRight(), wkRadii.bottomRight(), wkRadii.bottomLeft());
 
     SkRRect r;
     r.setRectRadii(rect.rect(), radii);
 
     clipRRect(r, AntiAliased, regionOp);
 }
 
 void GraphicsContext::clipOut(const Path& pathToClip)
 {
@@ skipping 28 matching lines @@
     if (contextDisabled())
         return;
 
     ASSERT(numPoints > 2);
 
     SkPath path;
     setPathFromPoints(&path, numPoints, points);
     clipPath(path, antialiased ? AntiAliased : NotAntiAliased);
 }
 
-void GraphicsContext::clipOutRoundedRect(const RoundedRect& rect)
+void GraphicsContext::clipOutRoundedRect(const FloatRoundedRect& rect)
 {
     if (contextDisabled())
         return;
 
     clipRoundedRect(rect, SkRegion::kDifference_Op);
 }
 
 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
@@ skipping 102 matching lines @@
 {
     if (contextDisabled())
         return;
 
     CompositeOperator previousOperator = compositeOperation();
     setCompositeOperation(op);
     fillRect(rect, color);
     setCompositeOperation(previousOperator);
 }
 
-void GraphicsContext::fillRoundedRect(const RoundedRect& rect, const Color& color)
+void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rect, const Color& color)
 {
     if (contextDisabled())
         return;
 
     if (rect.isRounded())
         fillRoundedRect(rect.rect(), rect.radii().topLeft(), rect.radii().topRight(), rect.radii().bottomLeft(), rect.radii().bottomRight(), color);
     else
         fillRect(rect.rect(), color);
 }
 
-void GraphicsContext::fillRectWithRoundedHole(const IntRect& rect, const RoundedRect& roundedHoleRect, const Color& color)
+void GraphicsContext::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
 {
     if (contextDisabled())
         return;
 
     Path path;
     path.addRect(rect);
 
     if (!roundedHoleRect.radii().isZero())
         path.addRoundedRect(roundedHoleRect);
     else
@@ skipping 75 matching lines @@
 {
     path->incReserve(numPoints);
     path->moveTo(WebCoreFloatToSkScalar(points[0].x()),
                  WebCoreFloatToSkScalar(points[0].y()));
     for (size_t i = 1; i < numPoints; ++i) {
         path->lineTo(WebCoreFloatToSkScalar(points[i].x()),
                      WebCoreFloatToSkScalar(points[i].y()));
     }
 }
 
-void GraphicsContext::setRadii(SkVector* radii, IntSize topLeft, IntSize topRight, IntSize bottomRight, IntSize bottomLeft)
+void GraphicsContext::setRadii(SkVector* radii, FloatSize topLeft, FloatSize topRight, FloatSize bottomRight, FloatSize bottomLeft)
 {
     radii[SkRRect::kUpperLeft_Corner].set(SkIntToScalar(topLeft.width()),
         SkIntToScalar(topLeft.height()));
     radii[SkRRect::kUpperRight_Corner].set(SkIntToScalar(topRight.width()),
         SkIntToScalar(topRight.height()));
     radii[SkRRect::kLowerRight_Corner].set(SkIntToScalar(bottomRight.width()),
         SkIntToScalar(bottomRight.height()));
     radii[SkRRect::kLowerLeft_Corner].set(SkIntToScalar(bottomLeft.width()),
         SkIntToScalar(bottomLeft.height()));
 }
@@ skipping 198 matching lines @@
 GraphicsContext::AutoCanvasRestorer::~AutoCanvasRestorer()
 {
     while (m_restoreCount) {
         m_canvas->restore();
         m_restoreCount--;
     }
 
 }
 
 } // namespace blink