Reduce number of vector buffer reallocs in Regions::unite .

Source/platform/geometry/Region.h

 /*
  * 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
@@ skipping 60 matching lines @@
         }
 
         int y;
         size_t segmentIndex;
     };
 
     class Shape {
     public:
         Shape();
         Shape(const IntRect&);
+        Shape(size_t segmentsCapacity, size_t spansCapacity);
 
         IntRect bounds() const;
         bool isEmpty() const { return m_spans.isEmpty(); }
         bool isRect() const { return m_spans.size() <= 2 && m_segments.size() <= 2; }
 
         typedef const Span* SpanIterator;
         SpanIterator spansBegin() const;
         SpanIterator spansEnd() const;
+        size_t spansSize() const { return m_spans.size(); }
 
         typedef const int* SegmentIterator;
         SegmentIterator segmentsBegin(SpanIterator) const;
         SegmentIterator segmentsEnd(SpanIterator) const;
+        size_t segmentsSize() const { return m_segments.size(); }
 
         static Shape unionShapes(const Shape& shape1, const Shape& shape2);
         static Shape intersectShapes(const Shape& shape1, const Shape& shape2);
         static Shape subtractShapes(const Shape& shape1, const Shape& shape2);
 
         void translate(const IntSize&);
         void swap(Shape&);
 
         struct CompareContainsOperation;
         struct CompareIntersectsOperation;
 
         template<typename CompareOperation>
         static bool compareShapes(const Shape& shape1, const Shape& shape2);
+        void trimCapacities();
 
 #ifndef NDEBUG
         void dump() const;
 #endif
 
     private:
         struct UnionOperation;
         struct IntersectOperation;
         struct SubtractOperation;
 
         template<typename Operation>
         static Shape shapeOperation(const Shape& shape1, const Shape& shape2);
 
         void appendSegment(int x);
         void appendSpan(int y);
         void appendSpan(int y, SegmentIterator begin, SegmentIterator end);
         void appendSpans(const Shape&, SpanIterator begin, SpanIterator end);
 
         bool canCoalesce(SegmentIterator begin, SegmentIterator end);
 
-        Vector<int, 32> m_segments;
-        Vector<Span, 16> m_spans;
+        static const size_t segmentsDefaultCapacity = 32;
+        static const size_t segmentsMask = segmentsDefaultCapacity - 1;
+        Vector<int, segmentsDefaultCapacity> m_segments;
+        static const size_t spansDefaultCapacity = 16;
+        static const size_t spansMask = spansDefaultCapacity - 1;
+        Vector<Span, spansDefaultCapacity> m_spans;
 
         friend bool operator==(const Shape&, const Shape&);
     };
 
     IntRect m_bounds;
     Shape m_shape;
 
     friend bool operator==(const Region&, const Region&);
     friend bool operator==(const Shape&, const Shape&);
     friend bool operator==(const Span&, const Span&);
@@ skipping 34 matching lines @@
 }
 
 inline bool operator==(const Region::Span& a, const Region::Span& b)
 {
     return a.y == b.y && a.segmentIndex == b.segmentIndex;
 }
 
 } // namespace WebCore
 
 #endif // Region_h