Add method Vector::shrinkToReasonableCapacity()

Source/wtf/Vector.h

Index: Source/wtf/Vector.h
diff --git a/Source/wtf/Vector.h b/Source/wtf/Vector.h
index ab18fe5fe421fae435d5627c5adcc6542d981021..47302cc0b399e8c4d565030a1bd36ef394c9f8b7 100644
--- a/Source/wtf/Vector.h
+++ b/Source/wtf/Vector.h
@@ -675,6 +675,11 @@ static const size_t kInitialVectorSize = WTF_VECTOR_INITIAL_SIZE;
         void reserveCapacity(size_t newCapacity);
         void reserveInitialCapacity(size_t initialCapacity);
         void shrinkToFit() { shrinkCapacity(size()); }
+        void shrinkToReasonableCapacity()
+        {
+            if (size() * 2 < capacity())
+                shrinkToFit();

[danakj, 2014/04/15 22:21:40]

How about: shrinkCapacity(size() * 2)?

So a series of
for i to 1000 {
  insert()
  shrinkToReasonableCapacity()
}
don't cause some crazy behaviour?

Also, do you need to check for integer overflow here?

[ostap, 2014/04/15 22:46:34]

I thought that shrinkToFit() would be better for memory saving.
May be use value from ::expandCapacity():

shrinkCapacity(size() + size() / 4 + 1)

?
Why it would? In this cycle capacity will be always less than size * 2.
There is comment in ::expandCapacity() that allocations can't be more than (2^31
- 1) on 32 bit systems and more than 2^32 on 64 bit, so size() * 2 normally
cannot produce integer overflow.

[danakj, 2014/04/15 22:53:25]

Oh, yes I agree. I didn't read the method far enough, stopped at the *= 2;
shrinkToFit() does shrinkCapacity(size()), so the next insert would mean that we
have to expandCapacity() each time, right?

+        }
 
         void clear() { shrinkCapacity(0); }