remove backref code.

The current backref implementation is designed to ensure that if a V8
object is converted to a ruby object, it gets the same
`Data_Wrap_Struct` every time it is passed to Ruby.

While this is not necessarily a bad approach, it is definitely what I'd
classify as an optimization. The current issues with The Ruby Racer all
center around stability and none center around performance, and so I'd
like to remove it until such time as we have that as a hard
requirement. I know that it will result in more object allocations in
both the Ruby world and the V8 world, but the trade off is code that is
more difficult to reason about, and might be prone to subtle race
conditions that involve multiple garbage collectors.

The Ruby side already has an identity map, so that we can resolve
'sameness' at the layer above.

Author: cowboyd

ext/v8/backref.cc

@@ -12,7 +12,6 @@ extern "C" {
     Isolate::Init();
     Handles::Init();
     Context::Init();
-    Backref::Init();
     Maybe::Init();
     Value::Init();
     Object::Init();
@@ -35,7 +34,6 @@ extern "C" {
     // Signature::Init();
     // Date::Init();
     // Constants::Init();
-    // External::Init();
     // Template::Init();
     // Stack::Init();
     // Message::Init();

ext/v8/backref.h

@@ -55,46 +55,14 @@ namespace rr {
   }
 
   Object::operator VALUE() {
-    Locker lock(getIsolate());
+    Isolate isolate(getIsolate());
+    Locker lock(isolate);
 
-    if (handle.IsEmpty()) {
-      return Qnil;
+    if (handle->IsFunction()) {
+      return Function(isolate, handle.As<v8::Function>());
     }
 
-    Backref* backref;
-
-    v8::Local<v8::String> key(v8::String::NewFromUtf8(getIsolate(), "rr::Backref"));
-    v8::Local<v8::Value> external = handle->GetHiddenValue(key);
-
-    VALUE value;
-
-    if (external.IsEmpty()) {
-      value = downcast();
-      backref = new Backref(value);
-
-      handle->SetHiddenValue(key, backref->toExternal(getIsolate()));
-    } else {
-      v8::External* wrapper = v8::External::Cast(*external);
-      backref = (Backref*)wrapper->Value();
-      value = backref->get();
-
-      if (!RTEST(value)) {
-        value = downcast();
-        backref->set(value);
-      }
-    }
-
-    return value;
-  }
-
-  VALUE Object::downcast() {
-    Locker lock(getIsolate());
-
     // TODO: Enable this when the methods are implemented
-    // if (handle->IsFunction()) {
-    //   return Function((v8::Handle<v8::Function>) v8::Function::Cast(*handle));
-    // }
-    //
     // if (handle->IsArray()) {
     //   return Array((v8::Handle<v8::Array>)v8::Array::Cast(*handle));
     // }

ext/v8/init.cc

@@ -56,11 +56,7 @@ namespace rr {
 
     inline Object(VALUE value) : Ref<v8::Object>(value) {}
     inline Object(v8::Isolate* isolate, v8::Handle<v8::Object> object) : Ref<v8::Object>(isolate, object) {}
-
-    virtual operator VALUE();
-
-  protected:
-    VALUE downcast();
+    operator VALUE();
   };
 
 }

ext/v8/object.cc

@@ -33,8 +33,6 @@ inline VALUE not_implemented(const char* message) {
 #include "context.h"
 
 #include "value.h"
-#include "backref.h"
-
 #include "object.h"
 #include "array.h"
 #include "primitive.h"

ext/v8/object.h

@@ -24,8 +24,8 @@
 
     fn.Call(@ctx.Global, [one, two, 3])
 
-    expect(@ctx.Global.Get(@ctx, V8::C::String.NewFromUtf8(@isolate, 'one')).FromJust()).to eq one
-    expect(@ctx.Global.Get(@ctx, V8::C::String.NewFromUtf8(@isolate, 'two')).FromJust()).to eq two
+    expect(@ctx.Global.Get(@ctx, V8::C::String.NewFromUtf8(@isolate, 'one')).FromJust().StrictEquals(one)).to be true
+    expect(@ctx.Global.Get(@ctx, V8::C::String.NewFromUtf8(@isolate, 'two')).FromJust().StrictEquals(two)).to be true
     expect(@ctx.Global.Get(@ctx, V8::C::String.NewFromUtf8(@isolate, 'three')).FromJust().Value()).to eq 3
   end
 

ext/v8/rr.h

@@ -51,13 +51,4 @@
   #   o.Set(property, V8::C::String::New('Bro! '))
   #   o.Get(property).Utf8Value().should eql 'Bro! I am Legend'
   # end
-
-  it 'always returns the same ruby object for the same V8 object' do
-    key = V8::C::String.NewFromUtf8(@isolate, 'two')
-    one = V8::C::Object.New(@isolate)
-    two = V8::C::Object.New(@isolate)
-
-    one.Set(@ctx, key, two)
-    expect(one.Get(@ctx, key).FromJust()).to be two
-  end
 end

spec/c/function_spec.rb

@@ -35,6 +35,6 @@ def convert(value)
     object = V8::C::Object.New(@isolate)
     object.Set(@ctx, V8::C::String.NewFromUtf8(@isolate, 'test'), 1)
 
-    expect(convert(object)).to eq object
+    expect(convert(object).StrictEquals(object)).to be true
   end
 end