blink: Rename platform/ methods to prefix with get when they collide.

third_party/WebKit/Source/core/paint/BoxBorderPainter.cpp

 // Copyright 2015 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 "core/paint/BoxBorderPainter.h"
 
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/style/BorderEdge.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 149 matching lines @@
     }
 
     return sideRect;
 }
 
 FloatRoundedRect calculateAdjustedInnerBorder(const FloatRoundedRect& innerBorder, BoxSide side)
 {
     // Expand the inner border as necessary to make it a rounded rect (i.e. radii contained within each edge).
     // This function relies on the fact we only get radii not contained within each edge if one of the radii
     // for an edge is zero, so we can shift the arc towards the zero radius corner.
-    FloatRoundedRect::Radii newRadii = innerBorder.radii();
+    FloatRoundedRect::Radii newRadii = innerBorder.getRadii();
     FloatRect newRect = innerBorder.rect();
 
     float overshoot;
     float maxRadii;
 
     switch (side) {
     case BSTop:
         overshoot = newRadii.topLeft().width() + newRadii.topRight().width() - newRect.width();
         // FIXME: once we start pixel-snapping rounded rects after this point, the overshoot concept
         // should disappear.
@@ skipping 541 matching lines @@
     ASSERT(edge.shouldRender());
     const Color color(edge.color.red(), edge.color.green(), edge.color.blue(), alpha);
 
     FloatRect sideRect = m_outer.rect();
     const Path* path = nullptr;
 
     // TODO(fmalita): find a way to consolidate these without sacrificing readability.
     switch (side) {
     case BSTop: {
         bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().topLeft(), m_inner.radii().topRight()));
+            || borderWillArcInnerEdge(m_inner.getRadii().topLeft(), m_inner.getRadii().topRight()));
         if (usePath)
             path = &borderInfo.roundedBorderPath;
         else
             sideRect.setHeight(edge.width);
 
         paintOneBorderSide(context, sideRect, BSTop, BSLeft, BSRight, path, borderInfo.antiAlias,
             color, completedEdges);
         break;
     }
     case BSBottom: {
         bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().bottomRight()));
+            || borderWillArcInnerEdge(m_inner.getRadii().bottomLeft(), m_inner.getRadii().bottomRight()));
         if (usePath)
             path = &borderInfo.roundedBorderPath;
         else
             sideRect.shiftYEdgeTo(sideRect.maxY() - edge.width);
 
         paintOneBorderSide(context, sideRect, BSBottom, BSLeft, BSRight, path, borderInfo.antiAlias,
             color, completedEdges);
         break;
     }
     case BSLeft: {
         bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomLeft(), m_inner.radii().topLeft()));
+            || borderWillArcInnerEdge(m_inner.getRadii().bottomLeft(), m_inner.getRadii().topLeft()));
         if (usePath)
             path = &borderInfo.roundedBorderPath;
         else
             sideRect.setWidth(edge.width);
 
         paintOneBorderSide(context, sideRect, BSLeft, BSTop, BSBottom, path, borderInfo.antiAlias,
             color, completedEdges);
         break;
     }
     case BSRight: {
         bool usePath = m_isRounded && (borderStyleHasInnerDetail(edge.borderStyle())
-            || borderWillArcInnerEdge(m_inner.radii().bottomRight(), m_inner.radii().topRight()));
+            || borderWillArcInnerEdge(m_inner.getRadii().bottomRight(), m_inner.getRadii().topRight()));
         if (usePath)
             path = &borderInfo.roundedBorderPath;
         else
             sideRect.shiftXEdgeTo(sideRect.maxX() - edge.width);
 
         paintOneBorderSide(context, sideRect, BSRight, BSTop, BSBottom, path, borderInfo.antiAlias,
             color, completedEdges);
         break;
     }
     default:
@@ skipping 256 matching lines @@
     //       3  /              \  3
     //         0----------------3
     //
     switch (side) {
     case BSTop:
         quad[0] = FloatPoint(outerRect.minXMinYCorner());
         quad[1] = FloatPoint(innerRect.minXMinYCorner());
         quad[2] = FloatPoint(innerRect.maxXMinYCorner());
         quad[3] = FloatPoint(outerRect.maxXMinYCorner());
 
-        if (!m_inner.radii().topLeft().isZero()) {
+        if (!m_inner.getRadii().topLeft().isZero()) {
             findIntersection(quad[0], quad[1],
                 FloatPoint(
-                    quad[1].x() + m_inner.radii().topLeft().width(),
+                    quad[1].x() + m_inner.getRadii().topLeft().width(),
                     quad[1].y()),
                 FloatPoint(
                     quad[1].x(),
-                    quad[1].y() + m_inner.radii().topLeft().height()),
+                    quad[1].y() + m_inner.getRadii().topLeft().height()),
                 quad[1]);
         }
 
-        if (!m_inner.radii().topRight().isZero()) {
+        if (!m_inner.getRadii().topRight().isZero()) {
             findIntersection(quad[3], quad[2],
                 FloatPoint(
-                    quad[2].x() - m_inner.radii().topRight().width(),
+                    quad[2].x() - m_inner.getRadii().topRight().width(),
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
-                    quad[2].y() + m_inner.radii().topRight().height()),
+                    quad[2].y() + m_inner.getRadii().topRight().height()),
                 quad[2]);
         }
         break;
 
     case BSLeft:
         quad[0] = FloatPoint(outerRect.minXMinYCorner());
         quad[1] = FloatPoint(innerRect.minXMinYCorner());
         quad[2] = FloatPoint(innerRect.minXMaxYCorner());
         quad[3] = FloatPoint(outerRect.minXMaxYCorner());
 
-        if (!m_inner.radii().topLeft().isZero()) {
+        if (!m_inner.getRadii().topLeft().isZero()) {
             findIntersection(quad[0], quad[1],
                 FloatPoint(
-                    quad[1].x() + m_inner.radii().topLeft().width(),
+                    quad[1].x() + m_inner.getRadii().topLeft().width(),
                     quad[1].y()),
                 FloatPoint(
                     quad[1].x(),
-                    quad[1].y() + m_inner.radii().topLeft().height()),
+                    quad[1].y() + m_inner.getRadii().topLeft().height()),
                 quad[1]);
         }
 
-        if (!m_inner.radii().bottomLeft().isZero()) {
+        if (!m_inner.getRadii().bottomLeft().isZero()) {
             findIntersection(quad[3], quad[2],
                 FloatPoint(
-                    quad[2].x() + m_inner.radii().bottomLeft().width(),
+                    quad[2].x() + m_inner.getRadii().bottomLeft().width(),
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
-                    quad[2].y() - m_inner.radii().bottomLeft().height()),
+                    quad[2].y() - m_inner.getRadii().bottomLeft().height()),
                 quad[2]);
         }
         break;
 
     case BSBottom:
         quad[0] = FloatPoint(outerRect.minXMaxYCorner());
         quad[1] = FloatPoint(innerRect.minXMaxYCorner());
         quad[2] = FloatPoint(innerRect.maxXMaxYCorner());
         quad[3] = FloatPoint(outerRect.maxXMaxYCorner());
 
-        if (!m_inner.radii().bottomLeft().isZero()) {
+        if (!m_inner.getRadii().bottomLeft().isZero()) {
             findIntersection(quad[0], quad[1],
                 FloatPoint(
-                    quad[1].x() + m_inner.radii().bottomLeft().width(),
+                    quad[1].x() + m_inner.getRadii().bottomLeft().width(),
                     quad[1].y()),
                 FloatPoint(
                     quad[1].x(),
-                    quad[1].y() - m_inner.radii().bottomLeft().height()),
+                    quad[1].y() - m_inner.getRadii().bottomLeft().height()),
                 quad[1]);
         }
 
-        if (!m_inner.radii().bottomRight().isZero()) {
+        if (!m_inner.getRadii().bottomRight().isZero()) {
             findIntersection(quad[3], quad[2],
                 FloatPoint(
-                    quad[2].x() - m_inner.radii().bottomRight().width(),
+                    quad[2].x() - m_inner.getRadii().bottomRight().width(),
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
-                    quad[2].y() - m_inner.radii().bottomRight().height()),
+                    quad[2].y() - m_inner.getRadii().bottomRight().height()),
                 quad[2]);
         }
         break;
 
     case BSRight:
         quad[0] = FloatPoint(outerRect.maxXMinYCorner());
         quad[1] = FloatPoint(innerRect.maxXMinYCorner());
         quad[2] = FloatPoint(innerRect.maxXMaxYCorner());
         quad[3] = FloatPoint(outerRect.maxXMaxYCorner());
 
-        if (!m_inner.radii().topRight().isZero()) {
+        if (!m_inner.getRadii().topRight().isZero()) {
             findIntersection(quad[0], quad[1],
                 FloatPoint(
-                    quad[1].x() - m_inner.radii().topRight().width(),
+                    quad[1].x() - m_inner.getRadii().topRight().width(),
                     quad[1].y()),
                 FloatPoint(
                     quad[1].x(),
-                    quad[1].y() + m_inner.radii().topRight().height()),
+                    quad[1].y() + m_inner.getRadii().topRight().height()),
                 quad[1]);
         }
 
-        if (!m_inner.radii().bottomRight().isZero()) {
+        if (!m_inner.getRadii().bottomRight().isZero()) {
             findIntersection(quad[3], quad[2],
                 FloatPoint(
-                    quad[2].x() - m_inner.radii().bottomRight().width(),
+                    quad[2].x() - m_inner.getRadii().bottomRight().width(),
                     quad[2].y()),
                 FloatPoint(
                     quad[2].x(),
-                    quad[2].y() - m_inner.radii().bottomRight().height()),
+                    quad[2].y() - m_inner.getRadii().bottomRight().height()),
                 quad[2]);
         }
         break;
     }
 
     if (firstMiter == secondMiter) {
         graphicsContext.clipPolygon(4, quad, firstMiter == SoftMiter);
         return;
     }
 
@@ skipping 33 matching lines @@
         FloatPoint secondQuad[4];
         secondQuad[0] = quad[0];
         secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
         secondQuad[2] = quad[2];
         secondQuad[3] = quad[3];
         graphicsContext.clipPolygon(4, secondQuad, secondMiter == SoftMiter);
     }
 }
 
 } // namespace blink