Add a dependency from Gin to base

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 "gin/array_buffer.h"
 
 #include <stdlib.h>
 
 namespace gin {
 
@@ skipping 35 matching lines @@
 // actually owns the memory. To determine when V8 is done with the memory, we
 // open a weak handle to the ArrayBuffer object. When we receive the weak
 // callback, we know the object is about to be garbage collected and we can
 // drop V8's implied reference to the memory.
 //
 // The final subtlety is that we need every ArrayBuffer into the same array
 // buffer to AddRef the same ArrayBuffer::Private. To make that work, we store
 // a pointer to the ArrayBuffer::Private object in an internal field of the
 // ArrayBuffer object.
 //
-class ArrayBuffer::Private {
+class ArrayBuffer::Private : public base::RefCounted<ArrayBuffer::Private> {
  public:
   static scoped_refptr<Private> From(v8::Isolate* isolate,
                                      v8::Handle<v8::ArrayBuffer> array);
 
-  void AddRef();
-  void Release();
-
   void* buffer() const { return buffer_; }
   size_t length() const { return length_; }
 
  private:
+  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);
 
-  size_t ref_count_;
   v8::Persistent<v8::ArrayBuffer> array_buffer_;
+  scoped_refptr<Private> self_reference_;
   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)));
   }
   return make_scoped_refptr(new Private(isolate, array));
 }
 
-void ArrayBuffer::Private::AddRef() {
-  ++ref_count_;
-}
-
-void ArrayBuffer::Private::Release() {
-  if (--ref_count_)
-    return;
-  delete this;
-}
-
 ArrayBuffer::Private::Private(v8::Isolate* isolate,
                               v8::Handle<v8::ArrayBuffer> array)
-    : ref_count_(0),
-      array_buffer_(isolate, array) {
+    : array_buffer_(isolate, array) {
   // Take ownership of the array buffer.
   v8::ArrayBuffer::Contents contents = array->Externalize();
   buffer_ = contents.Data();
   length_ = contents.ByteLength();
 
   array->SetAlignedPointerInInternalField(kBufferViewPrivateIndex, this);
 
-  AddRef();  // Balanced in WeakCallback.
+  self_reference_ = this;  // Cleared in WeakCallback.
   array_buffer_.SetWeak(this, WeakCallback);
 }
 
 ArrayBuffer::Private::~Private() {
   ArrayBufferAllocator::SharedInstance()->Free(buffer_, length_);
 }
 
 void ArrayBuffer::Private::WeakCallback(
     const v8::WeakCallbackData<v8::ArrayBuffer, Private>& data) {
   Private* parameter = data.GetParameter();
   parameter->array_buffer_.Reset();
-  parameter->Release();  // Balanced in ArrayBuffer::Private::Private.
+  // parameter->self_reference_.clear();
 }
 
 // ArrayBuffer ----------------------------------------------------------------
 
 ArrayBuffer::ArrayBuffer(v8::Isolate* isolate)
     : isolate_(isolate),
       bytes_(0),
       num_bytes_(0) {
 }
 
@@ skipping 41 matching lines @@
 bool Converter<ArrayBufferView>::FromV8(v8::Handle<v8::Value> val,
                                         ArrayBufferView* out) {
   if (!val->IsArrayBufferView())
     return false;
   *out = ArrayBufferView(out->isolate(),
                          v8::Handle<v8::ArrayBufferView>::Cast(val));
   return true;
 }
 
 }  // namespace gin