Get rid of fastMallocGoodSize() and replace it with something generic.

Source/wtf/WTF.h

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_h
 #define WTF_h
 
 #include "wtf/Compiler.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PartitionAlloc.h"
+#include <limits.h>
 
 namespace WTF {
 
 // This function must be called exactly once from the main thread before using anything else in WTF.
 WTF_EXPORT void initialize(TimeFunction currentTimeFunction, TimeFunction monotonicallyIncreasingTimeFunction);
 WTF_EXPORT void shutdown();
 
 class Partitions {
 public:
     static void initialize();
     static void shutdown();
     static ALWAYS_INLINE PartitionRoot* getBufferPartition() { return m_bufferAllocator.root(); }
 
 private:
     static PartitionAllocator<4096> m_bufferAllocator;
 };
 
 
+class QuantizedAllocation {

[abarth-chromium, 2013/09/07 05:08:24]

Why is this in WTF.h?  Please put it in its own header.

+public:
+    static const size_t kMaxAllocation = 32768;
+    static const size_t kMaxRounding = 4096;
+    static const size_t kMinRounding = 16;
+    static const size_t kMinRoundingLimit = 256;
+    static const size_t kTableSize = kMaxAllocation / kMinRoundingLimit;

[abarth-chromium, 2013/09/07 05:08:24]

Can you add some comments explaining where these numbers come from?

+
+    // Using "unsigned" is not a limitation because Chromium's max malloc() is 2GB even on 64-bit.
+    static const size_t kMaxUnquantizedAllocation = UINT_MAX - kMaxRounding;
+
+    static void init();
+
+    static size_t quantizedSize(size_t size)
+    {
+        size_t roundToLessOne;
+        if (UNLIKELY(size >= kMaxAllocation))
+            roundToLessOne = kMaxRounding - 1;
+        else
+            roundToLessOne = table[size / kMinRoundingLimit];
+        return (size + roundToLessOne) & ~roundToLessOne;
+    }
+
+private:
+    static unsigned short table[kTableSize];
+};
+
 } // namespace WTF
 
 #endif // WTF_h