• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include <stdlib.h>
6 
7 #include "base/logging.h"
8 #include "gin/array_buffer.h"
9 #include "gin/per_isolate_data.h"
10 
11 namespace gin {
12 
13 namespace {
14 
15 gin::WrapperInfo g_array_buffer_wrapper_info = {gin::kEmbedderNativeGin};
16 
17 }  // namespace
18 
19 COMPILE_ASSERT(V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT == 2,
20                array_buffers_must_have_two_internal_fields);
21 
22 // ArrayBufferAllocator -------------------------------------------------------
23 
Allocate(size_t length)24 void* ArrayBufferAllocator::Allocate(size_t length) {
25   return calloc(1, length);
26 }
27 
AllocateUninitialized(size_t length)28 void* ArrayBufferAllocator::AllocateUninitialized(size_t length) {
29   return malloc(length);
30 }
31 
Free(void * data,size_t length)32 void ArrayBufferAllocator::Free(void* data, size_t length) {
33   free(data);
34 }
35 
SharedInstance()36 ArrayBufferAllocator* ArrayBufferAllocator::SharedInstance() {
37   static ArrayBufferAllocator* instance = new ArrayBufferAllocator();
38   return instance;
39 }
40 
41 // ArrayBuffer::Private -------------------------------------------------------
42 
43 // This class exists to solve a tricky lifetime problem. The V8 API doesn't
44 // want to expose a direct view into the memory behind an array buffer because
45 // V8 might deallocate that memory during garbage collection. Instead, the V8
46 // API forces us to externalize the buffer and take ownership of the memory.
47 // In order to know when to free the memory, we need to figure out both when
48 // we're done with it and when V8 is done with it.
49 //
50 // To determine whether we're done with the memory, every view we have into
51 // the array buffer takes a reference to the ArrayBuffer::Private object that
52 // actually owns the memory. To determine when V8 is done with the memory, we
53 // open a weak handle to the ArrayBuffer object. When we receive the weak
54 // callback, we know the object is about to be garbage collected and we can
55 // drop V8's implied reference to the memory.
56 //
57 // The final subtlety is that we need every ArrayBuffer into the same array
58 // buffer to AddRef the same ArrayBuffer::Private. To make that work, we store
59 // a pointer to the ArrayBuffer::Private object in an internal field of the
60 // ArrayBuffer object.
61 //
62 class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
63  public:
64   static scoped_refptr<Private> From(v8::Isolate* isolate,
65                                      v8::Handle<v8::ArrayBuffer> array);
66 
buffer() const67   void* buffer() const { return buffer_; }
length() const68   size_t length() const { return length_; }
69 
70  private:
71   friend class base::RefCounted<Private>;
72 
73   Private(v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array);
74   ~Private();
75 
76   static void WeakCallback(
77       const v8::WeakCallbackData<v8::ArrayBuffer, Private>& data);
78 
79   v8::Persistent<v8::ArrayBuffer> array_buffer_;
80   scoped_refptr<Private> self_reference_;
81   v8::Isolate* isolate_;
82   void* buffer_;
83   size_t length_;
84 };
85 
From(v8::Isolate * isolate,v8::Handle<v8::ArrayBuffer> array)86 scoped_refptr<ArrayBuffer::Private> ArrayBuffer::Private::From(
87     v8::Isolate* isolate, v8::Handle<v8::ArrayBuffer> array) {
88   if (array->IsExternal()) {
89     CHECK_EQ(WrapperInfo::From(v8::Handle<v8::Object>::Cast(array)),
90              &g_array_buffer_wrapper_info)
91         << "Cannot mix blink and gin ArrayBuffers";
92     return make_scoped_refptr(static_cast<Private*>(
93         array->GetAlignedPointerFromInternalField(kEncodedValueIndex)));
94   }
95   return make_scoped_refptr(new Private(isolate, array));
96 }
97 
Private(v8::Isolate * isolate,v8::Handle<v8::ArrayBuffer> array)98 ArrayBuffer::Private::Private(v8::Isolate* isolate,
99                               v8::Handle<v8::ArrayBuffer> array)
100     : array_buffer_(isolate, array), isolate_(isolate) {
101   // Take ownership of the array buffer.
102   CHECK(!array->IsExternal());
103   v8::ArrayBuffer::Contents contents = array->Externalize();
104   buffer_ = contents.Data();
105   length_ = contents.ByteLength();
106 
107   array->SetAlignedPointerInInternalField(kWrapperInfoIndex,
108                                           &g_array_buffer_wrapper_info);
109   array->SetAlignedPointerInInternalField(kEncodedValueIndex, this);
110 
111   self_reference_ = this;  // Cleared in WeakCallback.
112   array_buffer_.SetWeak(this, WeakCallback);
113 }
114 
~Private()115 ArrayBuffer::Private::~Private() {
116   PerIsolateData::From(isolate_)->allocator()->Free(buffer_, length_);
117 }
118 
WeakCallback(const v8::WeakCallbackData<v8::ArrayBuffer,Private> & data)119 void ArrayBuffer::Private::WeakCallback(
120     const v8::WeakCallbackData<v8::ArrayBuffer, Private>& data) {
121   Private* parameter = data.GetParameter();
122   parameter->array_buffer_.Reset();
123   parameter->self_reference_ = NULL;
124 }
125 
126 // ArrayBuffer ----------------------------------------------------------------
127 
ArrayBuffer()128 ArrayBuffer::ArrayBuffer()
129     : bytes_(0),
130       num_bytes_(0) {
131 }
132 
ArrayBuffer(v8::Isolate * isolate,v8::Handle<v8::ArrayBuffer> array)133 ArrayBuffer::ArrayBuffer(v8::Isolate* isolate,
134                          v8::Handle<v8::ArrayBuffer> array) {
135   private_ = ArrayBuffer::Private::From(isolate, array);
136   bytes_ = private_->buffer();
137   num_bytes_ = private_->length();
138 }
139 
~ArrayBuffer()140 ArrayBuffer::~ArrayBuffer() {
141 }
142 
operator =(const ArrayBuffer & other)143 ArrayBuffer& ArrayBuffer::operator=(const ArrayBuffer& other) {
144   private_ = other.private_;
145   bytes_ = other.bytes_;
146   num_bytes_ = other.num_bytes_;
147   return *this;
148 }
149 
150 // Converter<ArrayBuffer> -----------------------------------------------------
151 
FromV8(v8::Isolate * isolate,v8::Handle<v8::Value> val,ArrayBuffer * out)152 bool Converter<ArrayBuffer>::FromV8(v8::Isolate* isolate,
153                                     v8::Handle<v8::Value> val,
154                                     ArrayBuffer* out) {
155   if (!val->IsArrayBuffer())
156     return false;
157   *out = ArrayBuffer(isolate, v8::Handle<v8::ArrayBuffer>::Cast(val));
158   return true;
159 }
160 
161 // ArrayBufferView ------------------------------------------------------------
162 
ArrayBufferView()163 ArrayBufferView::ArrayBufferView()
164     : offset_(0),
165       num_bytes_(0) {
166 }
167 
ArrayBufferView(v8::Isolate * isolate,v8::Handle<v8::ArrayBufferView> view)168 ArrayBufferView::ArrayBufferView(v8::Isolate* isolate,
169                                  v8::Handle<v8::ArrayBufferView> view)
170     : array_buffer_(isolate, view->Buffer()),
171       offset_(view->ByteOffset()),
172       num_bytes_(view->ByteLength()) {
173 }
174 
~ArrayBufferView()175 ArrayBufferView::~ArrayBufferView() {
176 }
177 
operator =(const ArrayBufferView & other)178 ArrayBufferView& ArrayBufferView::operator=(const ArrayBufferView& other) {
179   array_buffer_ = other.array_buffer_;
180   offset_ = other.offset_;
181   num_bytes_ = other.num_bytes_;
182   return *this;
183 }
184 
185 
186 // Converter<ArrayBufferView> -------------------------------------------------
187 
FromV8(v8::Isolate * isolate,v8::Handle<v8::Value> val,ArrayBufferView * out)188 bool Converter<ArrayBufferView>::FromV8(v8::Isolate* isolate,
189                                         v8::Handle<v8::Value> val,
190                                         ArrayBufferView* out) {
191   if (!val->IsArrayBufferView())
192     return false;
193   *out = ArrayBufferView(isolate, v8::Handle<v8::ArrayBufferView>::Cast(val));
194   return true;
195 }
196 
197 }  // namespace gin
198