Revert "Use V8 implementation of ArrayBuffer in Blink."

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "bindings/v8/SerializedScriptValue.h"
 
+#include "V8ArrayBuffer.h"
 #include "V8ArrayBufferView.h"
 #include "V8Blob.h"
 #include "V8DOMFileSystem.h"
 #include "V8DataView.h"
 #include "V8File.h"
 #include "V8FileList.h"
 #include "V8Float32Array.h"
 #include "V8ImageData.h"
 #include "V8Int16Array.h"
 #include "V8Int32Array.h"
@@ skipping 630 matching lines @@
 
 static v8::Handle<v8::Object> toV8Object(MessagePort* impl, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Handle<v8::Object>();
     v8::Handle<v8::Value> wrapper = toV8(impl, v8::Handle<v8::Object>(), isolate);
     ASSERT(wrapper->IsObject());
     return wrapper.As<v8::Object>();
 }
 
-static v8::Handle<v8::ArrayBuffer> toV8Object(ArrayBuffer* impl, v8::Isolate* isolate)
+static v8::Handle<v8::Object> toV8Object(ArrayBuffer* impl, v8::Isolate* isolate)
 {
     if (!impl)
-        return v8::Handle<v8::ArrayBuffer>();
+        return v8::Handle<v8::Object>();
     v8::Handle<v8::Value> wrapper = toV8(impl, v8::Handle<v8::Object>(), isolate);
-    ASSERT(wrapper->IsArrayBuffer());
-    return wrapper.As<v8::ArrayBuffer>();
+    ASSERT(wrapper->IsObject());
+    return wrapper.As<v8::Object>();
 }
 
 class Serializer {
     class StateBase;
 public:
     enum Status {
         Success,
         InputError,
         DataCloneError,
         InvalidStateError,
@@ skipping 137 matching lines @@
             , m_nameDone(false)
             , m_isSerializingAccessor(false)
         {
         }
 
         virtual uint32_t execDepth() const { return m_isSerializingAccessor ? 1 : 0; }
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer&) = 0;
 
-        StateBase* serializeProperties(bool ignoreIndexed, Serializer& serializer)
+        StateBase* serializeProperties(bool ignoreIndexed, Serializer& serializer) 
         {
             m_isSerializingAccessor = false;
             while (m_index < m_propertyNames->Length()) {
                 bool isAccessor = false;
                 if (!m_nameDone) {
                     v8::Local<v8::Value> propertyName = m_propertyNames->Get(m_index);
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
                     if (propertyName.IsEmpty())
                         return serializer.reportFailure(this);
@@ skipping 112 matching lines @@
     };
 
     class SparseArrayState : public AbstractObjectState {
     public:
         SparseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next)
             : AbstractObjectState(array, next)
         {
             m_propertyNames = v8::Local<v8::Array>::New(propertyNames);
         }
 
-        virtual StateBase* advance(Serializer& serializer)
+        virtual StateBase* advance(Serializer& serializer) 
         {
             return serializeProperties(false, serializer);
         }
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
         }
     };
@@ skipping 178 matching lines @@
     {
         ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
             return handleError(DataCloneError, next);
         m_writer.writeTransferredArrayBuffer(index);
         return 0;
     }
 
-    static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
+    static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount) 
     {
         // Let K be the cost of serializing all property values that are there
         // Cost of serializing sparsely: 5*propertyCount + K (5 bytes per uint32_t key)
         // Cost of serializing densely: K + 1*(length - propertyCount) (1 byte for all properties that are not there)
         // so densely is better than sparsly whenever 6*propertyCount > length
         return 6 * propertyCount >= length;
     }
 
     StateBase* startArrayState(v8::Handle<v8::Array> array, StateBase* next)
     {
@@ skipping 501 matching lines @@
     }
 
     bool readNumber(v8::Handle<v8::Value>* value)
     {
         double number;
         if (!doReadNumber(&number))
             return false;
         *value = v8::Number::New(number);
         return true;
     }
-
+  
     bool readNumberObject(v8::Handle<v8::Value>* value)
     {
         double number;
         if (!doReadNumber(&number))
             return false;
         *value = v8::NumberObject::New(number);
         return true;
     }
 
     bool readImageData(v8::Handle<v8::Value>* value)
@@ skipping 51 matching lines @@
         RefPtr<ArrayBuffer> arrayBuffer;
         v8::Handle<v8::Value> arrayBufferV8Value;
         if (!readArrayBufferViewSubTag(&subTag))
             return false;
         if (!doReadUint32(&byteOffset))
             return false;
         if (!doReadUint32(&byteLength))
             return false;
         if (!creator.consumeTopOfStack(&arrayBufferV8Value))
             return false;
-        if (arrayBufferV8Value.IsEmpty())
+        if (arrayBufferV8Value.IsEmpty()) 
             return false;
         arrayBuffer = V8ArrayBuffer::toNative(arrayBufferV8Value.As<v8::Object>());
         if (!arrayBuffer)
             return false;
         switch (subTag) {
         case ByteArrayTag:
             *value = toV8(Int8Array::create(arrayBuffer.release(), byteOffset, byteLength), v8::Handle<v8::Object>(), m_isolate);
             break;
         case UnsignedByteArrayTag:
             *value = toV8(Uint8Array::create(arrayBuffer.release(), byteOffset, byteLength), v8::Handle<v8::Object>(),  m_isolate);
@@ skipping 575 matching lines @@
     RefPtr<SerializedScriptValue> result = adoptRef(new SerializedScriptValue(m_data));
     m_data = String();
     return result.release();
 }
 
 SerializedScriptValue::SerializedScriptValue()
     : m_externallyAllocatedMemory(0)
 {
 }
 
-inline void neuterBinding(ArrayBuffer* object)
+template<typename T>
+inline void neuterBinding(T* object) 
 {
     Vector<DOMDataStore*>& allStores = V8PerIsolateData::current()->allStores();
     for (size_t i = 0; i < allStores.size(); i++) {
-        v8::Handle<v8::Object> wrapper = allStores[i]->get(object);
-        if (!wrapper.IsEmpty()) {
-            ASSERT(wrapper->IsArrayBuffer());
-            v8::Handle<v8::ArrayBuffer>::Cast(wrapper)->Neuter();
-        }
-    }
-}
-
-inline void neuterBinding(ArrayBufferView* object)
-{
-    Vector<DOMDataStore*>& allStores = V8PerIsolateData::current()->allStores();
-    for (size_t i = 0; i < allStores.size(); i++) {
         v8::Handle<v8::Object> wrapper = allStores[i]->get(object);
         if (!wrapper.IsEmpty())
             wrapper->SetIndexedPropertiesToExternalArrayData(0, v8::kExternalByteArray, 0);
     }
 }
 
 PassOwnPtr<SerializedScriptValue::ArrayBufferContentsArray> SerializedScriptValue::transferArrayBuffers(ArrayBufferArray& arrayBuffers, bool& didThrow, v8::Isolate* isolate)
 {
     ASSERT(arrayBuffers.size());
 
@@ skipping 123 matching lines @@
         v8::V8::AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 uint32_t SerializedScriptValue::wireFormatVersion()
 {
     return WebCore::wireFormatVersion;
 }
 
 } // namespace WebCore