Move Region.cpp/.h to platform/

Source/platform/geometry/Region.cpp

 /*
  * Copyright (C) 2010, 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-#include "core/platform/graphics/Region.h"
+#include "platform/geometry/Region.h"
 
 #include <stdio.h>
 
 // A region class based on the paper "Scanline Coherent Shape Algebra"
 // by Jonathan E. Steinhart from the book "Graphics Gems II".
 //
 // This implementation uses two vectors instead of linked list, and
 // also compresses regions when possible.
 
 namespace WebCore {
 
 Region::Region()
 {
 }
 
 Region::Region(const IntRect& rect)
     : m_bounds(rect)
     , m_shape(rect)
 {
 }
 
 Vector<IntRect> Region::rects() const
 {
     Vector<IntRect> rects;
 
-    for (Shape::SpanIterator span = m_shape.spans_begin(), end = m_shape.spans_end(); span != end && span + 1 != end; ++span) {
+    for (Shape::SpanIterator span = m_shape.spansBegin(), end = m_shape.spansEnd(); span != end && span + 1 != end; ++span) {
         int y = span->y;
         int height = (span + 1)->y - y;
 
-        for (Shape::SegmentIterator segment = m_shape.segments_begin(span), end = m_shape.segments_end(span); segment != end && segment + 1 != end; segment += 2) {
+        for (Shape::SegmentIterator segment = m_shape.segmentsBegin(span), end = m_shape.segmentsEnd(span); segment != end && segment + 1 != end; segment += 2) {
             int x = *segment;
             int width = *(segment + 1) - x;
 
             rects.append(IntRect(x, y, width, height));
         }
     }
 
     return rects;
 }
 
 bool Region::contains(const Region& region) const
 {
     if (!m_bounds.contains(region.m_bounds))
         return false;
 
     return Shape::compareShapes<Shape::CompareContainsOperation>(m_shape, region.m_shape);
 }
 
 bool Region::contains(const IntPoint& point) const
 {
     if (!m_bounds.contains(point))
         return false;
 
-    for (Shape::SpanIterator span = m_shape.spans_begin(), end = m_shape.spans_end(); span != end && span + 1 != end; ++span) {
+    for (Shape::SpanIterator span = m_shape.spansBegin(), end = m_shape.spansEnd(); span != end && span + 1 != end; ++span) {
         int y = span->y;
         int maxY = (span + 1)->y;
 
         if (y > point.y())
             break;
         if (maxY <= point.y())
             continue;
 
-        for (Shape::SegmentIterator segment = m_shape.segments_begin(span), end = m_shape.segments_end(span); segment != end && segment + 1 != end; segment += 2) {
+        for (Shape::SegmentIterator segment = m_shape.segmentsBegin(span), end = m_shape.segmentsEnd(span); segment != end && segment + 1 != end; segment += 2) {
             int x = *segment;
             int maxX = *(segment + 1);
 
             if (x > point.x())
                 break;
             if (maxX > point.x())
                 return true;
         }
     }
 
@@ skipping 20 matching lines @@
     }
 
     return totalArea;
 }
 
 template<typename CompareOperation>
 bool Region::Shape::compareShapes(const Shape& aShape, const Shape& bShape)
 {
     bool result = CompareOperation::defaultResult;
 
-    Shape::SpanIterator aSpan = aShape.spans_begin();
-    Shape::SpanIterator aSpanEnd = aShape.spans_end();
-    Shape::SpanIterator bSpan = bShape.spans_begin();
-    Shape::SpanIterator bSpanEnd = bShape.spans_end();
+    Shape::SpanIterator aSpan = aShape.spansBegin();
+    Shape::SpanIterator aSpanEnd = aShape.spansEnd();
+    Shape::SpanIterator bSpan = bShape.spansBegin();
+    Shape::SpanIterator bSpanEnd = bShape.spansEnd();
 
     bool aHadSegmentInPreviousSpan = false;
     bool bHadSegmentInPreviousSpan = false;
     while (aSpan != aSpanEnd && aSpan + 1 != aSpanEnd && bSpan != bSpanEnd && bSpan + 1 != bSpanEnd) {
         int aY = aSpan->y;
         int aMaxY = (aSpan + 1)->y;
         int bY = bSpan->y;
         int bMaxY = (bSpan + 1)->y;
 
-        Shape::SegmentIterator aSegment = aShape.segments_begin(aSpan);
-        Shape::SegmentIterator aSegmentEnd = aShape.segments_end(aSpan);
-        Shape::SegmentIterator bSegment = bShape.segments_begin(bSpan);
-        Shape::SegmentIterator bSegmentEnd = bShape.segments_end(bSpan);
+        Shape::SegmentIterator aSegment = aShape.segmentsBegin(aSpan);
+        Shape::SegmentIterator aSegmentEnd = aShape.segmentsEnd(aSpan);
+        Shape::SegmentIterator bSegment = bShape.segmentsBegin(bSpan);
+        Shape::SegmentIterator bSegmentEnd = bShape.segmentsEnd(bSpan);
 
         // Look for a non-overlapping part of the spans. If B had a segment in its previous span, then we already tested A against B within that span.
         bool aHasSegmentInSpan = aSegment != aSegmentEnd;
         bool bHasSegmentInSpan = bSegment != bSegmentEnd;
         if (aY < bY && !bHadSegmentInPreviousSpan && aHasSegmentInSpan && CompareOperation::aOutsideB(result))
             return result;
         if (bY < aY && !aHadSegmentInPreviousSpan && bHasSegmentInSpan && CompareOperation::bOutsideA(result))
             return result;
 
         aHadSegmentInPreviousSpan = aHasSegmentInSpan;
         bHadSegmentInPreviousSpan = bHasSegmentInSpan;
 
         bool spansOverlap = bMaxY > aY && bY < aMaxY;
         if (spansOverlap) {
             while (aSegment != aSegmentEnd && bSegment != bSegmentEnd) {
                 int aX = *aSegment;
                 int aMaxX = *(aSegment + 1);
                 int bX = *bSegment;
                 int bMaxX = *(bSegment + 1);
 
                 bool segmentsOverlap = bMaxX > aX && bX < aMaxX;
                 if (segmentsOverlap && CompareOperation::aOverlapsB(result))
                     return result;
                 if (aX < bX && CompareOperation::aOutsideB(result))
                     return result;
                 if (bX < aX && CompareOperation::bOutsideA(result))
                     return result;
 
-                if (aMaxX < bMaxX)
+                if (aMaxX < bMaxX) {
                     aSegment += 2;
-                else if (bMaxX < aMaxX)
+                } else if (bMaxX < aMaxX) {
                     bSegment += 2;
-                else {
+                } else {
                     aSegment += 2;
                     bSegment += 2;
                 }
             }
 
             if (aSegment != aSegmentEnd && CompareOperation::aOutsideB(result))
                 return result;
             if (bSegment != bSegmentEnd && CompareOperation::bOutsideA(result))
                 return result;
         }
 
-        if (aMaxY < bMaxY)
+        if (aMaxY < bMaxY) {
             aSpan += 1;
-        else if (bMaxY < aMaxY)
+        } else if (bMaxY < aMaxY) {
             bSpan += 1;
-        else {
+        } else {
             aSpan += 1;
             bSpan += 1;
         }
     }
 
     if (aSpan != aSpanEnd && aSpan + 1 != aSpanEnd && CompareOperation::aOutsideB(result))
         return result;
     if (bSpan != bSpanEnd && bSpan + 1 != bSpanEnd && CompareOperation::bOutsideA(result))
         return result;
 
@@ skipping 56 matching lines @@
     if (canCoalesce(begin, end))
         return;
 
     appendSpan(y);
     m_segments.appendRange(begin, end);
 }
 
 void Region::Shape::appendSpans(const Shape& shape, SpanIterator begin, SpanIterator end)
 {
     for (SpanIterator it = begin; it != end; ++it)
-        appendSpan(it->y, shape.segments_begin(it), shape.segments_end(it));
+        appendSpan(it->y, shape.segmentsBegin(it), shape.segmentsEnd(it));
 }
 
 void Region::Shape::appendSegment(int x)
 {
     m_segments.append(x);
 }
 
-Region::Shape::SpanIterator Region::Shape::spans_begin() const
+Region::Shape::SpanIterator Region::Shape::spansBegin() const
 {
     return m_spans.data();
 }
 
-Region::Shape::SpanIterator Region::Shape::spans_end() const
+Region::Shape::SpanIterator Region::Shape::spansEnd() const
 {
     return m_spans.data() + m_spans.size();
 }
 
-Region::Shape::SegmentIterator Region::Shape::segments_begin(SpanIterator it) const
+Region::Shape::SegmentIterator Region::Shape::segmentsBegin(SpanIterator it) const
 {
     ASSERT(it >= m_spans.data());
     ASSERT(it < m_spans.data() + m_spans.size());
 
     // Check if this span has any segments.
     if (it->segmentIndex == m_segments.size())
         return 0;
 
     return &m_segments[it->segmentIndex];
 }
 
-Region::Shape::SegmentIterator Region::Shape::segments_end(SpanIterator it) const
+Region::Shape::SegmentIterator Region::Shape::segmentsEnd(SpanIterator it) const
 {
     ASSERT(it >= m_spans.data());
     ASSERT(it < m_spans.data() + m_spans.size());
 
     // Check if this span has any segments.
     if (it->segmentIndex == m_segments.size())
         return 0;
 
     ASSERT(it + 1 < m_spans.data() + m_spans.size());
     size_t segmentIndex = (it + 1)->segmentIndex;
 
     ASSERT_WITH_SECURITY_IMPLICATION(segmentIndex <= m_segments.size());
     return m_segments.data() + segmentIndex;
 }
 
 #ifndef NDEBUG
 void Region::Shape::dump() const
 {
-    for (Shape::SpanIterator span = spans_begin(), end = spans_end(); span != end; ++span) {
+    for (Shape::SpanIterator span = spansBegin(), end = spansEnd(); span != end; ++span) {
         printf("%6d: (", span->y);
 
-        for (Shape::SegmentIterator segment = segments_begin(span), end = segments_end(span); segment != end; ++segment)
+        for (Shape::SegmentIterator segment = segmentsBegin(span), end = segmentsEnd(span); segment != end; ++segment)
             printf("%d ", *segment);
         printf(")\n");
     }
 
     printf("\n");
 }
 #endif
 
 IntRect Region::Shape::bounds() const
 {
     if (isEmpty())
         return IntRect();
 
-    SpanIterator span = spans_begin();
+    SpanIterator span = spansBegin();
     int minY = span->y;
 
-    SpanIterator lastSpan = spans_end() - 1;
+    SpanIterator lastSpan = spansEnd() - 1;
     int maxY = lastSpan->y;
 
     int minX = std::numeric_limits<int>::max();
     int maxX = std::numeric_limits<int>::min();
 
     while (span != lastSpan) {
-        SegmentIterator firstSegment = segments_begin(span);
-        SegmentIterator lastSegment = segments_end(span) - 1;
+        SegmentIterator firstSegment = segmentsBegin(span);
+        SegmentIterator lastSegment = segmentsEnd(span) - 1;
 
         if (firstSegment && lastSegment) {
             ASSERT(firstSegment != lastSegment);
 
             if (*firstSegment < minX)
                 minX = *firstSegment;
 
             if (*lastSegment > maxX)
                 maxX = *lastSegment;
         }
@@ skipping 29 matching lines @@
 template<typename Operation>
 Region::Shape Region::Shape::shapeOperation(const Shape& shape1, const Shape& shape2)
 {
     COMPILE_ASSERT(!(!Operation::shouldAddRemainingSegmentsFromSpan1 && Operation::shouldAddRemainingSegmentsFromSpan2), invalid_segment_combination);
     COMPILE_ASSERT(!(!Operation::shouldAddRemainingSpansFromShape1 && Operation::shouldAddRemainingSpansFromShape2), invalid_span_combination);
 
     Shape result;
     if (Operation::trySimpleOperation(shape1, shape2, result))
         return result;
 
-    SpanIterator spans1 = shape1.spans_begin();
-    SpanIterator spans1End = shape1.spans_end();
+    SpanIterator spans1 = shape1.spansBegin();
+    SpanIterator spans1End = shape1.spansEnd();
 
-    SpanIterator spans2 = shape2.spans_begin();
-    SpanIterator spans2End = shape2.spans_end();
+    SpanIterator spans2 = shape2.spansBegin();
+    SpanIterator spans2End = shape2.spansEnd();
 
     SegmentIterator segments1 = 0;
     SegmentIterator segments1End = 0;
 
     SegmentIterator segments2 = 0;
     SegmentIterator segments2End = 0;
 
     // Iterate over all spans.
     while (spans1 != spans1End && spans2 != spans2End) {
         int y = 0;
         int test = spans1->y - spans2->y;
 
         if (test <= 0) {
             y = spans1->y;
 
-            segments1 = shape1.segments_begin(spans1);
-            segments1End = shape1.segments_end(spans1);
+            segments1 = shape1.segmentsBegin(spans1);
+            segments1End = shape1.segmentsEnd(spans1);
             ++spans1;
         }
         if (test >= 0) {
             y = spans2->y;
 
-            segments2 = shape2.segments_begin(spans2);
-            segments2End = shape2.segments_end(spans2);
+            segments2 = shape2.segmentsBegin(spans2);
+            segments2End = shape2.segmentsEnd(spans2);
             ++spans2;
         }
 
         int flag = 0;
         int oldFlag = 0;
 
         SegmentIterator s1 = segments1;
         SegmentIterator s2 = segments2;
 
         Vector<int, 32> segments;
@@ skipping 98 matching lines @@
 };
 
 Region::Shape Region::Shape::subtractShapes(const Shape& shape1, const Shape& shape2)
 {
     return shapeOperation<SubtractOperation>(shape1, shape2);
 }
 
 #ifndef NDEBUG
 void Region::dump() const
 {
-    printf("Bounds: (%d, %d, %d, %d)\n",
-           m_bounds.x(), m_bounds.y(), m_bounds.width(), m_bounds.height());
+    printf("Bounds: (%d, %d, %d, %d)\n", m_bounds.x(), m_bounds.y(), m_bounds.width(), m_bounds.height());
     m_shape.dump();
 }
 #endif
 
 void Region::intersect(const Region& region)
 {
     if (m_bounds.isEmpty())
         return;
     if (!m_bounds.intersects(region.m_bounds)) {
         m_shape = Shape();
@@ skipping 43 matching lines @@
     m_bounds = m_shape.bounds();
 }
 
 void Region::translate(const IntSize& offset)
 {
     m_bounds.move(offset);
     m_shape.translate(offset);
 }
 
 } // namespace WebCore