bindings: Adds DOMArrayBuffer, etc. as thin wrappers for ArrayBuffer, etc.

Source/bindings/core/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 14 matching lines @@
  * 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/core/v8/SerializedScriptValue.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/V8ArrayBuffer.h"
+#include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Blob.h"
+#include "bindings/core/v8/V8DataView.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
+#include "bindings/core/v8/V8Float32Array.h"
+#include "bindings/core/v8/V8Float64Array.h"
 #include "bindings/core/v8/V8ImageData.h"
+#include "bindings/core/v8/V8Int16Array.h"
+#include "bindings/core/v8/V8Int32Array.h"
+#include "bindings/core/v8/V8Int8Array.h"
 #include "bindings/core/v8/V8MessagePort.h"
+#include "bindings/core/v8/V8Uint16Array.h"
+#include "bindings/core/v8/V8Uint32Array.h"
+#include "bindings/core/v8/V8Uint8Array.h"
+#include "bindings/core/v8/V8Uint8ClampedArray.h"
 #include "bindings/core/v8/WorkerScriptController.h"
-#include "bindings/core/v8/custom/V8ArrayBufferCustom.h"
-#include "bindings/core/v8/custom/V8ArrayBufferViewCustom.h"
-#include "bindings/core/v8/custom/V8DataViewCustom.h"
-#include "bindings/core/v8/custom/V8Float32ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Float64ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Int16ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Int32ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Int8ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Uint16ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Uint32ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Uint8ArrayCustom.h"
-#include "bindings/core/v8/custom/V8Uint8ClampedArrayCustom.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
 #include "bindings/modules/v8/V8DOMFileSystem.h"
+#include "core/dom/DOMArrayBufferDeallocationObserver.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/MessagePort.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/DataView.h"
 #include "platform/SharedBuffer.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
@@ skipping 838 matching lines @@
 
 static v8::Handle<v8::Object> toV8Object(MessagePort* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Handle<v8::Object>();
     v8::Handle<v8::Value> wrapper = toV8(impl, creationContext, isolate);
     ASSERT(wrapper->IsObject());
     return wrapper.As<v8::Object>();
 }
 
-static v8::Handle<v8::ArrayBuffer> toV8Object(ArrayBuffer* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+static v8::Handle<v8::ArrayBuffer> toV8Object(DOMArrayBuffer* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Handle<v8::ArrayBuffer>();
     v8::Handle<v8::Value> wrapper = toV8(impl, creationContext, isolate);
     ASSERT(wrapper->IsArrayBuffer());
     return wrapper.As<v8::ArrayBuffer>();
 }
 
 class Serializer {
     class StateBase;
@@ skipping 441 matching lines @@
 
     void writeRegExp(v8::Handle<v8::Value> value)
     {
         v8::Handle<v8::RegExp> regExp = value.As<v8::RegExp>();
         m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags());
     }
 
     StateBase* writeAndGreyArrayBufferView(v8::Handle<v8::Object> object, StateBase* next)
     {
         ASSERT(!object.IsEmpty());
-        ArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
+        DOMArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
         if (!arrayBufferView)
             return 0;
         if (!arrayBufferView->buffer())
             return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         v8::Handle<v8::Value> underlyingBuffer = toV8(arrayBufferView->buffer(), m_scriptState->context()->Global(), isolate());
         if (underlyingBuffer.IsEmpty())
             return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         StateBase* stateOut = doSerializeArrayBuffer(underlyingBuffer, next);
         if (stateOut)
             return stateOut;
-        m_writer.writeArrayBufferView(*arrayBufferView);
+        m_writer.writeArrayBufferView(*arrayBufferView->view());
         // This should be safe: we serialize something that we know to be a wrapper (see
         // the toV8 call above), so the call to doSerializeArrayBuffer should neither
         // cause the system stack to overflow nor should it have potential to reach
         // this ArrayBufferView again.
         //
         // We do need to grey the underlying buffer before we grey its view, however;
         // ArrayBuffers may be shared, so they need to be given reference IDs, and an
         // ArrayBufferView cannot be constructed without a corresponding ArrayBuffer
         // (or without an additional tag that would allow us to do two-stage construction
         // like we do for Objects and Arrays).
         greyObject(object);
         return 0;
     }
 
     StateBase* writeArrayBuffer(v8::Handle<v8::Value> value, StateBase* next)
     {
-        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
+        DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
             return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         ASSERT(!m_transferredArrayBuffers.contains(value.As<v8::Object>()));
-        m_writer.writeArrayBuffer(*arrayBuffer);
+        m_writer.writeArrayBuffer(*arrayBuffer->buffer());
         return 0;
     }
 
     StateBase* writeTransferredArrayBuffer(v8::Handle<v8::Value> value, uint32_t index, StateBase* next)
     {
-        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
+        DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
             return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         m_writer.writeTransferredArrayBuffer(index);
         return 0;
     }
 
     static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
     {
@@ skipping 601 matching lines @@
 
     PassRefPtr<ArrayBuffer> doReadArrayBuffer()
     {
         uint32_t byteLength;
         if (!doReadUint32(&byteLength))
             return nullptr;
         if (m_position + byteLength > m_length)
             return nullptr;
         const void* bufferStart = m_buffer + m_position;
         RefPtr<ArrayBuffer> arrayBuffer = ArrayBuffer::create(bufferStart, byteLength);
-        arrayBuffer->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instanceTemplate());
+        arrayBuffer->setDeallocationObserver(DOMArrayBufferDeallocationObserver::instance());
         m_position += byteLength;
         return arrayBuffer.release();
     }
 
     bool readArrayBuffer(v8::Handle<v8::Value>* value)
     {
         RefPtr<ArrayBuffer> arrayBuffer = doReadArrayBuffer();
         if (!arrayBuffer)
             return false;
-        *value = toV8(arrayBuffer.release(), m_scriptState->context()->Global(), isolate());
+        *value = toV8(DOMArrayBuffer::create(arrayBuffer.release()), m_scriptState->context()->Global(), isolate());
         return true;
     }
 
     bool readArrayBufferView(v8::Handle<v8::Value>* value, CompositeCreator& creator)
     {
         ArrayBufferViewSubTag subTag;
         uint32_t byteOffset;
         uint32_t byteLength;
-        RefPtr<ArrayBuffer> arrayBuffer;
+        RefPtr<DOMArrayBuffer> 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())
             return false;
         arrayBuffer = V8ArrayBuffer::toImpl(arrayBufferV8Value.As<v8::Object>());
         if (!arrayBuffer)
             return false;
 
         v8::Handle<v8::Object> creationContext = m_scriptState->context()->Global();
         switch (subTag) {
         case ByteArrayTag:
-            *value = toV8(Int8Array::create(arrayBuffer.release(), byteOffset, byteLength), creationContext, isolate());
+            *value = toV8(DOMInt8Array::create(arrayBuffer, byteOffset, byteLength), creationContext, isolate());

[haraken, 2014/10/14 15:11:18]

I'd keep .release(), because we're conceptually releasing a RefPtr here.

[Yuki, 2014/10/15 09:35:22]

Done.

             break;
         case UnsignedByteArrayTag:
-            *value = toV8(Uint8Array::create(arrayBuffer.release(), byteOffset, byteLength), creationContext,  isolate());
+            *value = toV8(DOMUint8Array::create(arrayBuffer, byteOffset, byteLength), creationContext,  isolate());
             break;
         case UnsignedByteClampedArrayTag:
-            *value = toV8(Uint8ClampedArray::create(arrayBuffer.release(), byteOffset, byteLength), creationContext, isolate());
+            *value = toV8(DOMUint8ClampedArray::create(arrayBuffer, byteOffset, byteLength), creationContext, isolate());
             break;
         case ShortArrayTag: {
             uint32_t shortLength = byteLength / sizeof(int16_t);
             if (shortLength * sizeof(int16_t) != byteLength)
                 return false;
-            *value = toV8(Int16Array::create(arrayBuffer.release(), byteOffset, shortLength), creationContext, isolate());
+            *value = toV8(DOMInt16Array::create(arrayBuffer, byteOffset, shortLength), creationContext, isolate());
             break;
         }
         case UnsignedShortArrayTag: {
             uint32_t shortLength = byteLength / sizeof(uint16_t);
             if (shortLength * sizeof(uint16_t) != byteLength)
                 return false;
-            *value = toV8(Uint16Array::create(arrayBuffer.release(), byteOffset, shortLength), creationContext, isolate());
+            *value = toV8(DOMUint16Array::create(arrayBuffer, byteOffset, shortLength), creationContext, isolate());
             break;
         }
         case IntArrayTag: {
             uint32_t intLength = byteLength / sizeof(int32_t);
             if (intLength * sizeof(int32_t) != byteLength)
                 return false;
-            *value = toV8(Int32Array::create(arrayBuffer.release(), byteOffset, intLength), creationContext, isolate());
+            *value = toV8(DOMInt32Array::create(arrayBuffer, byteOffset, intLength), creationContext, isolate());
             break;
         }
         case UnsignedIntArrayTag: {
             uint32_t intLength = byteLength / sizeof(uint32_t);
             if (intLength * sizeof(uint32_t) != byteLength)
                 return false;
-            *value = toV8(Uint32Array::create(arrayBuffer.release(), byteOffset, intLength), creationContext, isolate());
+            *value = toV8(DOMUint32Array::create(arrayBuffer, byteOffset, intLength), creationContext, isolate());
             break;
         }
         case FloatArrayTag: {
             uint32_t floatLength = byteLength / sizeof(float);
             if (floatLength * sizeof(float) != byteLength)
                 return false;
-            *value = toV8(Float32Array::create(arrayBuffer.release(), byteOffset, floatLength), creationContext, isolate());
+            *value = toV8(DOMFloat32Array::create(arrayBuffer, byteOffset, floatLength), creationContext, isolate());
             break;
         }
         case DoubleArrayTag: {
             uint32_t floatLength = byteLength / sizeof(double);
             if (floatLength * sizeof(double) != byteLength)
                 return false;
-            *value = toV8(Float64Array::create(arrayBuffer.release(), byteOffset, floatLength), creationContext, isolate());
+            *value = toV8(DOMFloat64Array::create(arrayBuffer, byteOffset, floatLength), creationContext, isolate());
             break;
         }
         case DataViewTag:
-            *value = toV8(DataView::create(arrayBuffer.release(), byteOffset, byteLength), creationContext, isolate());
+            *value = toV8(DOMDataView::create(arrayBuffer, byteOffset, byteLength), creationContext, isolate());
             break;
         default:
             return false;
         }
         // The various *Array::create() methods will return null if the range the view expects is
         // mismatched with the range the buffer can provide or if the byte offset is not aligned
         // to the size of the element type.
         return !value->IsEmpty();
     }
 
@@ skipping 552 matching lines @@
     }
 
     virtual bool tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>* object) override
     {
         if (!m_arrayBufferContents)
             return false;
         if (index >= m_arrayBuffers.size())
             return false;
         v8::Handle<v8::Object> result = m_arrayBuffers.at(index);
         if (result.IsEmpty()) {
-            RefPtr<ArrayBuffer> buffer = ArrayBuffer::create(m_arrayBufferContents->at(index));
-            buffer->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instanceTemplate());
+            RefPtr<DOMArrayBuffer> buffer = DOMArrayBuffer::create(m_arrayBufferContents->at(index));
+            buffer->setDeallocationObserver(DOMArrayBufferDeallocationObserver::instance());
             v8::Isolate* isolate = m_reader.scriptState()->isolate();
             v8::Handle<v8::Object> creationContext = m_reader.scriptState()->context()->Global();
             isolate->AdjustAmountOfExternalAllocatedMemory(buffer->byteLength());
             result = toV8Object(buffer.get(), creationContext, isolate);
             m_arrayBuffers[index] = result;
         }
         *object = result;
         return true;
     }
 
@@ skipping 162 matching lines @@
         for (size_t i = 0; i < length; i++)
             dst[i] = htons(src[i]);
     }
 }
 
 SerializedScriptValue::SerializedScriptValue()
     : m_externallyAllocatedMemory(0)
 {
 }
 
-static void neuterArrayBufferInAllWorlds(ArrayBuffer* object)
+static void neuterArrayBufferInAllWorlds(DOMArrayBuffer* object)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (isMainThread()) {
         Vector<RefPtr<DOMWrapperWorld> > worlds;
         DOMWrapperWorld::allWorldsInMainThread(worlds);
         for (size_t i = 0; i < worlds.size(); i++) {
             v8::Handle<v8::Object> wrapper = worlds[i]->domDataStore().get<V8ArrayBuffer>(object, isolate);
             if (!wrapper.IsEmpty()) {
                 ASSERT(wrapper->IsArrayBuffer());
                 v8::Handle<v8::ArrayBuffer>::Cast(wrapper)->Neuter();
@@ skipping 14 matching lines @@
 
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (arrayBuffers[i]->isNeutered()) {
             exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is already neutered.");
             return nullptr;
         }
     }
 
     OwnPtr<ArrayBufferContentsArray> contents = adoptPtr(new ArrayBufferContentsArray(arrayBuffers.size()));
 
-    HashSet<ArrayBuffer*> visited;
+    HashSet<DOMArrayBuffer*> visited;
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (visited.contains(arrayBuffers[i].get()))
             continue;
         visited.add(arrayBuffers[i].get());
 
         bool result = arrayBuffers[i]->transfer(contents->at(i));
         if (!result) {
             exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " could not be transferred.");
             return nullptr;
         }
@@ skipping 99 matching lines @@
         // Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
         if (V8MessagePort::hasInstance(transferrable, isolate)) {
             RefPtrWillBeRawPtr<MessagePort> port = V8MessagePort::toImpl(v8::Handle<v8::Object>::Cast(transferrable));
             // Check for duplicate MessagePorts.
             if (ports.contains(port)) {
                 exceptionState.throwDOMException(DataCloneError, "Message port at index " + String::number(i) + " is a duplicate of an earlier port.");
                 return false;
             }
             ports.append(port.release());
         } else if (V8ArrayBuffer::hasInstance(transferrable, isolate)) {
-            RefPtr<ArrayBuffer> arrayBuffer = V8ArrayBuffer::toImpl(v8::Handle<v8::Object>::Cast(transferrable));
+            RefPtr<DOMArrayBuffer> arrayBuffer = V8ArrayBuffer::toImpl(v8::Handle<v8::Object>::Cast(transferrable));
             if (arrayBuffers.contains(arrayBuffer)) {
                 exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is a duplicate of an earlier ArrayBuffer.");
                 return false;
             }
             arrayBuffers.append(arrayBuffer.release());
         } else {
             exceptionState.throwDOMException(DataCloneError, "Value at index " + String::number(i) + " does not have a transferable type.");
             return false;
         }
     }
@@ skipping 13 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace blink