Remove unused code from WTF TypedArrays

Source/wtf/ArrayBufferView.h

 /*
  * Copyright (C) 2009 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 14 matching lines @@
 
 #ifndef ArrayBufferView_h
 #define ArrayBufferView_h
 
 #include "wtf/ArrayBuffer.h"
 
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/WTFExport.h"
-#include <algorithm>
 #include <limits.h>
 
 namespace WTF {
 
 class WTF_EXPORT ArrayBufferView : public RefCounted<ArrayBufferView> {
   public:
     enum ViewType {
         TypeInt8,
         TypeUint8,
         TypeUint8Clamped,
@@ skipping 32 matching lines @@
 
   protected:
     ArrayBufferView(PassRefPtr<ArrayBuffer>, unsigned byteOffset);
 
     inline bool setImpl(ArrayBufferView*, unsigned byteOffset);
 
     inline bool setRangeImpl(const char* data, size_t dataByteLength, unsigned byteOffset);
 
     inline bool zeroRangeImpl(unsigned byteOffset, size_t rangeByteLength);
 
-    static inline void calculateOffsetAndLength(int start, int end, unsigned arraySize,
-                                         unsigned* offset, unsigned* length);
-
     // Helper to verify that a given sub-range of an ArrayBuffer is
     // within range.
     template <typename T>
     static bool verifySubRange(PassRefPtr<ArrayBuffer> buffer,
                                unsigned byteOffset,
                                unsigned numElements)
     {
         if (!buffer)
             return false;
         if (sizeof(T) > 1 && byteOffset % sizeof(T))
             return false;
         if (byteOffset > buffer->byteLength())
             return false;
         unsigned remainingElements = (buffer->byteLength() - byteOffset) / sizeof(T);
         if (numElements > remainingElements)
             return false;
         return true;
     }
 
-    // Input offset is in number of elements from this array's view;
-    // output offset is in number of bytes from the underlying buffer's view.
-    template <typename T>
-    static void clampOffsetAndNumElements(PassRefPtr<ArrayBuffer> buffer,
-                                          unsigned arrayByteOffset,
-                                          unsigned *offset,
-                                          unsigned *numElements)
-    {
-        unsigned maxOffset = (UINT_MAX - arrayByteOffset) / sizeof(T);
-        if (*offset > maxOffset) {
-            *offset = buffer->byteLength();
-            *numElements = 0;
-            return;
-        }
-        *offset = arrayByteOffset + *offset * sizeof(T);
-        *offset = std::min(buffer->byteLength(), *offset);
-        unsigned remainingElements = (buffer->byteLength() - *offset) / sizeof(T);
-        *numElements = std::min(remainingElements, *numElements);
-    }
-
     virtual void neuter();
 
     // This is the address of the ArrayBuffer's storage, plus the byte offset.
     void* m_baseAddress;
 
     unsigned m_byteOffset : 31;
     bool m_isNeuterable : 1;
 
   private:
     friend class ArrayBuffer;
@@ skipping 37 matching lines @@
         || byteOffset + rangeByteLength < byteOffset) {
         // Out of range offset or overflow
         return false;
     }
 
     char* base = static_cast<char*>(baseAddress());
     memset(base + byteOffset, 0, rangeByteLength);
     return true;
 }
 
-void ArrayBufferView::calculateOffsetAndLength(int start, int end, unsigned arraySize,
-                                               unsigned* offset, unsigned* length)
-{
-    if (start < 0)
-        start += arraySize;
-    if (start < 0)
-        start = 0;
-    if (end < 0)
-        end += arraySize;
-    if (end < 0)
-        end = 0;
-    if (static_cast<unsigned>(end) > arraySize)
-        end = arraySize;
-    if (end < start)
-        end = start;
-    *offset = static_cast<unsigned>(start);
-    *length = static_cast<unsigned>(end - start);
-}
-
 } // namespace WTF
 
 using WTF::ArrayBufferView;
 
 #endif // ArrayBufferView_h