Imported QtWebKit TP3 (git b57bc6801f1876c3220d5a4bfea33d620d477443)

Change-Id: I3b1d8a2808782c9f34d50240000e20cb38d3680f
Reviewed-by: Konstantin Tokarev <annulen@yandex.ru>

1 files changed, 37 insertions, 39 deletions

diff --git a/Source/WTF/wtf/Bitmap.h b/Source/WTF/wtf/Bitmap.h
index 76a2ca4b3..c0571a81d 100644
--- a/Source/WTF/wtf/Bitmap.h
+++ b/Source/WTF/wtf/Bitmap.h
@@ -19,8 +19,8 @@
 #ifndef Bitmap_h
 #define Bitmap_h
 
+#include <array>
 #include <wtf/Atomics.h>
-#include <wtf/FixedArray.h>
 #include <wtf/StdLibExtras.h>
 #include <stdint.h>
 #include <string.h>
@@ -36,11 +36,9 @@ enum BitmapAtomicMode {
     BitmapAtomic
 };
 
-template<size_t size, BitmapAtomicMode atomicMode = BitmapNotAtomic>
+template<size_t Size, BitmapAtomicMode atomicMode = BitmapNotAtomic, typename WordType = uint32_t>
 class Bitmap {
-private:
-    typedef uint32_t WordType;
-
+    WTF_MAKE_FAST_ALLOCATED;
 public:
     Bitmap();
 
@@ -59,8 +57,8 @@ public:
     size_t isFull() const;
 
 private:
-    static const WordType wordSize = sizeof(WordType) * 8;
-    static const WordType words = (size + wordSize - 1) / wordSize;
+    static const unsigned wordSize = sizeof(WordType) * 8;
+    static const unsigned words = (Size + wordSize - 1) / wordSize;
 
     // the literal '1' is of type signed int.  We want to use an unsigned
     // version of the correct size when doing the calculations because if
@@ -69,29 +67,29 @@ private:
     // a 64 bit unsigned int would give 0xffff8000
     static const WordType one = 1;
 
-    FixedArray<WordType, words> bits;
+    std::array<WordType, words> bits;
 };
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline Bitmap<size, atomicMode>::Bitmap()
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline Bitmap<size, atomicMode, WordType>::Bitmap()
 {
     clearAll();
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline bool Bitmap<size, atomicMode>::get(size_t n) const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline bool Bitmap<size, atomicMode, WordType>::get(size_t n) const
 {
     return !!(bits[n / wordSize] & (one << (n % wordSize)));
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline void Bitmap<size, atomicMode>::set(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline void Bitmap<size, atomicMode, WordType>::set(size_t n)
 {
     bits[n / wordSize] |= (one << (n % wordSize));
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline bool Bitmap<size, atomicMode>::testAndSet(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline bool Bitmap<size, atomicMode, WordType>::testAndSet(size_t n)
 {
     WordType mask = one << (n % wordSize);
     size_t index = n / wordSize;
@@ -100,8 +98,8 @@ inline bool Bitmap<size, atomicMode>::testAndSet(size_t n)
     return result;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline bool Bitmap<size, atomicMode>::testAndClear(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline bool Bitmap<size, atomicMode, WordType>::testAndClear(size_t n)
 {
     WordType mask = one << (n % wordSize);
     size_t index = n / wordSize;
@@ -110,8 +108,8 @@ inline bool Bitmap<size, atomicMode>::testAndClear(size_t n)
     return result;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline bool Bitmap<size, atomicMode>::concurrentTestAndSet(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline bool Bitmap<size, atomicMode, WordType>::concurrentTestAndSet(size_t n)
 {
     if (atomicMode == BitmapNotAtomic)
         return testAndSet(n);
@@ -126,12 +124,12 @@ inline bool Bitmap<size, atomicMode>::concurrentTestAndSet(size_t n)
         oldValue = *wordPtr;
         if (oldValue & mask)
             return true;
-    } while (!weakCompareAndSwap(wordPtr, oldValue, oldValue | mask));
+    } while (!weakCompareAndSwap(wordPtr, oldValue, static_cast<WordType>(oldValue | mask)));
     return false;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline bool Bitmap<size, atomicMode>::concurrentTestAndClear(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline bool Bitmap<size, atomicMode, WordType>::concurrentTestAndClear(size_t n)
 {
     if (atomicMode == BitmapNotAtomic)
         return testAndClear(n);
@@ -146,32 +144,32 @@ inline bool Bitmap<size, atomicMode>::concurrentTestAndClear(size_t n)
         oldValue = *wordPtr;
         if (!(oldValue & mask))
             return false;
-    } while (!weakCompareAndSwap(wordPtr, oldValue, oldValue & ~mask));
+    } while (!weakCompareAndSwap(wordPtr, oldValue, static_cast<WordType>(oldValue & ~mask)));
     return true;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline void Bitmap<size, atomicMode>::clear(size_t n)
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline void Bitmap<size, atomicMode, WordType>::clear(size_t n)
 {
     bits[n / wordSize] &= ~(one << (n % wordSize));
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline void Bitmap<size, atomicMode>::clearAll()
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline void Bitmap<size, atomicMode, WordType>::clearAll()
 {
     memset(bits.data(), 0, sizeof(bits));
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline size_t Bitmap<size, atomicMode>::nextPossiblyUnset(size_t start) const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline size_t Bitmap<size, atomicMode, WordType>::nextPossiblyUnset(size_t start) const
 {
     if (!~bits[start / wordSize])
         return ((start / wordSize) + 1) * wordSize;
     return start + 1;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline int64_t Bitmap<size, atomicMode>::findRunOfZeros(size_t runLength) const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline int64_t Bitmap<size, atomicMode, WordType>::findRunOfZeros(size_t runLength) const
 {
     if (!runLength) 
         runLength = 1; 
@@ -190,8 +188,8 @@ inline int64_t Bitmap<size, atomicMode>::findRunOfZeros(size_t runLength) const
     return -1;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline size_t Bitmap<size, atomicMode>::count(size_t start) const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline size_t Bitmap<size, atomicMode, WordType>::count(size_t start) const
 {
     size_t result = 0;
     for ( ; (start % wordSize); ++start) {
@@ -199,12 +197,12 @@ inline size_t Bitmap<size, atomicMode>::count(size_t start) const
             ++result;
     }
     for (size_t i = start / wordSize; i < words; ++i)
-        result += WTF::bitCount(bits[i]);
+        result += WTF::bitCount(static_cast<unsigned>(bits[i]));
     return result;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline size_t Bitmap<size, atomicMode>::isEmpty() const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline size_t Bitmap<size, atomicMode, WordType>::isEmpty() const
 {
     for (size_t i = 0; i < words; ++i)
         if (bits[i])
@@ -212,8 +210,8 @@ inline size_t Bitmap<size, atomicMode>::isEmpty() const
     return true;
 }
 
-template<size_t size, BitmapAtomicMode atomicMode>
-inline size_t Bitmap<size, atomicMode>::isFull() const
+template<size_t size, BitmapAtomicMode atomicMode, typename WordType>
+inline size_t Bitmap<size, atomicMode, WordType>::isFull() const
 {
     for (size_t i = 0; i < words; ++i)
         if (~bits[i])