gin: Make it possible to use gin array buffers when running on top of blink

gin/array_buffer.cc

 // Copyright 2013 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.
 
+#include <stdlib.h>
+
 #include "gin/array_buffer.h"
-
-#include <stdlib.h>
+#include "gin/per_isolate_data.h"
 
 namespace gin {
 
 COMPILE_ASSERT(V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT == 2,
                array_buffers_must_have_two_internal_fields);
 
 static const int kBufferViewPrivateIndex = 0;
 
 // ArrayBufferAllocator -------------------------------------------------------
 
@@ skipping 47 matching lines @@
   friend class base::RefCounted<Private>;
 
   Private(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array);
   ~Private();
 
   static void WeakCallback(
       const v8::WeakCallbackData<v8::ArrayBuffer, Private>& data);
 
   v8::Persistent<v8::ArrayBuffer> array_buffer_;
   scoped_refptr<Private> self_reference_;
+  v8::Isolate* isolate_;
   void* buffer_;
   size_t length_;
 };
 
 scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
     v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array) {
   if (array->IsExternal()) {
     return make_scoped_refptr(static_cast<Private*>(
         array->GetAlignedPointerFromInternalField(kBufferViewPrivateIndex)));

[abarth-chromium, 2014/02/19 15:52:55]

This CL is a good step, but I think you still get in trouble on this line.  How
do we know that this static_cast is safe?  If the ArrayBuffer is external
because Blink has made it external, this fields might not point to a
ArrayBuffer::Private...

   }
   return make_scoped_refptr(new Private(isolate, array));
 }
 
 ArrayBuffer::Private::Private(v8::Isolate* isolate,
                               v8::Handle<v8::ArrayBuffer> array)
-    : array_buffer_(isolate, array) {
+    : array_buffer_(isolate, array), isolate_(isolate) {
   // Take ownership of the array buffer.
+  CHECK(!array->IsExternal());
   v8::ArrayBuffer::Contents contents = array->Externalize();
   buffer_ = contents.Data();
   length_ = contents.ByteLength();
 
   array->SetAlignedPointerInInternalField(kBufferViewPrivateIndex, this);
 
   self_reference_ = this;  // Cleared in WeakCallback.
   array_buffer_.SetWeak(this, WeakCallback);
 }
 
 ArrayBuffer::Private::~Private() {
-  ArrayBufferAllocator::SharedInstance()->Free(buffer_, length_);
+  PerIsolateData::From(isolate_)->allocator()->Free(buffer_, length_);
 }
 
 void ArrayBuffer::Private::WeakCallback(
     const v8::WeakCallbackData<v8::ArrayBuffer, Private>& data) {
   Private* parameter = data.GetParameter();
   parameter->array_buffer_.Reset();
   parameter->self_reference_ = NULL;
 }
 
 // ArrayBuffer ----------------------------------------------------------------
@@ skipping 53 matching lines @@
 bool Converter<ArrayBufferView>::FromV8(v8::Isolate* isolate,
                                         v8::Handle<v8::Value> val,
                                         ArrayBufferView* out) {
   if (!val->IsArrayBufferView())
     return false;
   *out = ArrayBufferView(isolate, v8::Handle<v8::ArrayBufferView>::Cast(val));
   return true;
 }
 
 }  // namespace gin