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

Source/core/dom/DOMArrayBuffer.h

Index: Source/core/dom/DOMArrayBuffer.h
diff --git a/Source/core/dom/DOMArrayBuffer.h b/Source/core/dom/DOMArrayBuffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..536c4970f9553e70ffeff9c5a2f4629489d586fb
--- /dev/null
+++ b/Source/core/dom/DOMArrayBuffer.h
@@ -0,0 +1,65 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef DOMArrayBuffer_h
+#define DOMArrayBuffer_h
+
+#include "bindings/core/v8/ScriptWrappable.h"
+#include "wtf/ArrayBuffer.h"
+#include "wtf/RefCounted.h"
+
+namespace blink {
+
+class DOMArrayBuffer : public RefCounted<DOMArrayBuffer>, public ScriptWrappable {

[haraken, 2014/10/16 05:41:41]

Can we add final?

[Yuki, 2014/10/16 14:21:51]

Done.

+    DEFINE_WRAPPERTYPEINFO();
+public:
+    static PassRefPtr<DOMArrayBuffer> create(PassRefPtr<WTF::ArrayBuffer> buffer)
+    {
+        if (!buffer)

[haraken, 2014/10/16 05:41:41]

Can this happen? It's nasty that a create method can return nullptr. If this
shouldn't happen, you can add ASSERT(!buffer).

[tyoshino (SeeGerritForStatus), 2014/10/16 06:39:15]

ArrayBuffer::create() returns null when it fails to allocate memory. In
DOMWebSocket.cpp, this is used to propagate such an error. That said, we could
choose to allocate an ArrayBuffer and then only if it's successful create a
DOMArrayBuffer for DOMWebSocket.cpp's case.

[Yuki, 2014/10/16 14:21:51]

IIRC, XMLHttpRequest also treats nullptr to ArrayBuffer and I had to add this
check to pass the tests.

+            return nullptr;
+        return adoptRef(new DOMArrayBuffer(buffer));
+    }
+    static PassRefPtr<DOMArrayBuffer> create(unsigned numElements, unsigned elementByteSize)
+    {
+        return adoptRef(new DOMArrayBuffer(WTF::ArrayBuffer::create(numElements, elementByteSize)));
+    }
+    static PassRefPtr<DOMArrayBuffer> create(const void* source, unsigned byteLength)
+    {
+        return adoptRef(new DOMArrayBuffer(WTF::ArrayBuffer::create(source, byteLength)));
+    }
+    static PassRefPtr<DOMArrayBuffer> create(WTF::ArrayBufferContents& contents)
+    {
+        return adoptRef(new DOMArrayBuffer(WTF::ArrayBuffer::create(contents)));
+    }
+
+    const WTF::ArrayBuffer* buffer() const { return m_buffer.get(); }
+    WTF::ArrayBuffer* buffer() { return m_buffer.get(); }
+
+    const void* data() const { return buffer()->data(); }
+    unsigned long byteLength() const { return buffer()->byteLength(); }
+    void* data() { return buffer()->data(); }
+    bool transfer(WTF::ArrayBufferContents& result) { return buffer()->transfer(result); }
+    bool isNeutered() { return buffer()->isNeutered(); }
+    void setDeallocationObserver(WTF::ArrayBufferDeallocationObserver* observer)
+    {
+        buffer()->setDeallocationObserver(observer);
+    }
+
+    virtual v8::Handle<v8::Object> wrap(v8::Handle<v8::Object> creationContext, v8::Isolate*) override;
+    virtual v8::Handle<v8::Object> associateWithWrapper(const WrapperTypeInfo*, v8::Handle<v8::Object> wrapper, v8::Isolate*) override;
+
+protected:

[haraken, 2014/10/16 05:41:41]

DOMArrayBuffer isn't inherited, so protected won't make sense?

[Yuki, 2014/10/16 14:21:51]

It's because I don't have any reason to make this class final and I prefer
extensible code in general.  Changed to private:.

+    explicit DOMArrayBuffer(PassRefPtr<WTF::ArrayBuffer> buffer)
+        : m_buffer(buffer)
+    {
+        ASSERT(m_buffer);
+    }
+
+private:
+    RefPtr<WTF::ArrayBuffer> m_buffer;
+};
+
+} // namespace blink
+
+#endif // DOMArrayBuffer_h