remove most uses of raw handle constructors

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2612 matching lines @@
 
 THREADED_TEST(ArrayBuffer_JSInternalToExternal) {
   i::FLAG_harmony_array_buffer = true;
   i::FLAG_harmony_typed_arrays = true;
 
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
 
-  v8::Handle<v8::Value> result =
+  v8::Local<v8::Value> result =
       CompileRun("var ab1 = new ArrayBuffer(2);"
                  "var u8_a = new Uint8Array(ab1);"
                  "u8_a[0] = 0xAA;"
                  "u8_a[1] = 0xFF; u8_a.buffer");
-  Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::Cast(*result);
+  Local<v8::ArrayBuffer> ab1 = Local<v8::ArrayBuffer>::Cast(result);
   CHECK_EQ(2, static_cast<int>(ab1->ByteLength()));
   CHECK(!ab1->IsExternal());
   ScopedArrayBufferContents ab1_contents(ab1->Externalize());
   CHECK(ab1->IsExternal());
 
   result = CompileRun("ab1.byteLength");
   CHECK_EQ(2, result->Int32Value());
   result = CompileRun("u8_a[0]");
   CHECK_EQ(0xAA, result->Int32Value());
   result = CompileRun("u8_a[1]");
@@ skipping 120 matching lines @@
       "var u8a = new Uint8Array(ab, 1, 1023);"
       "var u8c = new Uint8ClampedArray(ab, 1, 1023);"
       "var i8a = new Int8Array(ab, 1, 1023);"
       "var u16a = new Uint16Array(ab, 2, 511);"
       "var i16a = new Int16Array(ab, 2, 511);"
       "var u32a = new Uint32Array(ab, 4, 255);"
       "var i32a = new Int32Array(ab, 4, 255);"
       "var f32a = new Float32Array(ab, 4, 255);"
       "var f64a = new Float64Array(ab, 8, 127);");
 
-  v8::Handle<v8::ArrayBuffer> ab(v8::ArrayBuffer::Cast(*CompileRun("ab")));
+  v8::Handle<v8::ArrayBuffer> ab =
+      Local<v8::ArrayBuffer>::Cast(CompileRun("ab"));
 
-  v8::Handle<v8::Uint8Array> u8a(v8::Uint8Array::Cast(*CompileRun("u8a")));
-  v8::Handle<v8::Uint8ClampedArray> u8c(
-    v8::Uint8ClampedArray::Cast(*CompileRun("u8c")));
-  v8::Handle<v8::Int8Array> i8a(v8::Int8Array::Cast(*CompileRun("i8a")));
+  v8::Handle<v8::Uint8Array> u8a =
+      v8::Handle<v8::Uint8Array>::Cast(CompileRun("u8a"));
+  v8::Handle<v8::Uint8ClampedArray> u8c =
+      v8::Handle<v8::Uint8ClampedArray>::Cast(CompileRun("u8c"));
+  v8::Handle<v8::Int8Array> i8a =
+      v8::Handle<v8::Int8Array>::Cast(CompileRun("i8a"));
 
-  v8::Handle<v8::Uint16Array> u16a(
-    v8::Uint16Array::Cast(*CompileRun("u16a")));
-  v8::Handle<v8::Int16Array> i16a(
-    v8::Int16Array::Cast(*CompileRun("i16a")));
-  v8::Handle<v8::Uint32Array> u32a(
-    v8::Uint32Array::Cast(*CompileRun("u32a")));
-  v8::Handle<v8::Int32Array> i32a(
-    v8::Int32Array::Cast(*CompileRun("i32a")));
-  v8::Handle<v8::Float32Array> f32a(
-    v8::Float32Array::Cast(*CompileRun("f32a")));
-  v8::Handle<v8::Float64Array> f64a(
-    v8::Float64Array::Cast(*CompileRun("f64a")));
+  v8::Handle<v8::Uint16Array> u16a =
+      v8::Handle<v8::Uint16Array>::Cast(CompileRun("u16a"));
+  v8::Handle<v8::Int16Array> i16a =
+      v8::Handle<v8::Int16Array>::Cast(CompileRun("i16a"));
+  v8::Handle<v8::Uint32Array> u32a =
+      v8::Handle<v8::Uint32Array>::Cast(CompileRun("u32a"));
+  v8::Handle<v8::Int32Array> i32a =
+      v8::Handle<v8::Int32Array>::Cast(CompileRun("i32a"));
+  v8::Handle<v8::Float32Array> f32a =
+      v8::Handle<v8::Float32Array>::Cast(CompileRun("f32a"));
+  v8::Handle<v8::Float64Array> f64a =
+    v8::Handle<v8::Float64Array>::Cast(CompileRun("f64a"));
 
   ScopedArrayBufferContents contents(ab->Externalize());
   ab->Neuter();
   CHECK_EQ(0, static_cast<int>(ab->ByteLength()));
   CheckIsNeutered(u8a);
   CheckIsNeutered(u8c);
   CheckIsNeutered(i8a);
   CheckIsNeutered(u16a);
   CheckIsNeutered(i16a);
   CheckIsNeutered(u32a);
@@ skipping 287 matching lines @@
 
 static void WeakPointerCallback(v8::Isolate* isolate,
                                 Persistent<Value>* handle,
                                 WeakCallCounter* counter) {
   CHECK_EQ(1234, counter->id());
   counter->increment();
   handle->Dispose(isolate);
 }
 
 
+static UniqueId MakeUniqueId(const Persistent<Value>& p) {
+  return UniqueId(reinterpret_cast<uintptr_t>(*v8::Utils::OpenPersistent(p)));
+}
+
+
 THREADED_TEST(ApiObjectGroups) {
   LocalContext env;
   v8::Isolate* iso = env->GetIsolate();
   HandleScope scope(iso);
 
   Persistent<Value> g1s1;
   Persistent<Value> g1s2;
   Persistent<Value> g1c1;
   Persistent<Value> g2s1;
   Persistent<Value> g2s2;
@@ skipping 17 matching lines @@
     g2s2.MakeWeak(iso, &counter, &WeakPointerCallback);
     g2c1.MakeWeak(iso, &counter, &WeakPointerCallback);
   }
 
   Persistent<Value> root(iso, g1s1);  // make a root.
 
   // Connect group 1 and 2, make a cycle.
   {
     HandleScope scope(iso);
     CHECK(Local<Object>::New(iso, g1s2.As<Object>())->
-            Set(0, Local<Value>(*g2s2)));
+            Set(0, Local<Value>::New(iso, g2s2)));
     CHECK(Local<Object>::New(iso, g2s1.As<Object>())->
-            Set(0, Local<Value>(*g1s1)));
+            Set(0, Local<Value>::New(iso, g1s1)));
   }
 
   {
-    UniqueId id1(reinterpret_cast<intptr_t>(*g1s1));
-    UniqueId id2(reinterpret_cast<intptr_t>(*g2s2));
+    UniqueId id1 = MakeUniqueId(g1s1);
+    UniqueId id2 = MakeUniqueId(g2s2);
     iso->SetObjectGroupId(g1s1, id1);
     iso->SetObjectGroupId(g1s2, id1);
     iso->SetReferenceFromGroup(id1, g1c1);
     iso->SetObjectGroupId(g2s1, id2);
     iso->SetObjectGroupId(g2s2, id2);
     iso->SetReferenceFromGroup(id2, g2c1);
   }
   // Do a single full GC, ensure incremental marking is stopped.
   v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
       iso)->heap();
   heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
 
   // All object should be alive.
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
   root.MakeWeak(iso, &counter, &WeakPointerCallback);
   // But make children strong roots---all the objects (except for children)
   // should be collectable now.
   g1c1.ClearWeak(iso);
   g2c1.ClearWeak(iso);
 
   // Groups are deleted, rebuild groups.
   {
-    UniqueId id1(reinterpret_cast<intptr_t>(*g1s1));
-    UniqueId id2(reinterpret_cast<intptr_t>(*g2s2));
+    UniqueId id1 = MakeUniqueId(g1s1);
+    UniqueId id2 = MakeUniqueId(g2s2);
     iso->SetObjectGroupId(g1s1, id1);
     iso->SetObjectGroupId(g1s2, id1);
     iso->SetReferenceFromGroup(id1, g1c1);
     iso->SetObjectGroupId(g2s1, id2);
     iso->SetObjectGroupId(g2s2, id2);
     iso->SetReferenceFromGroup(id2, g2c1);
   }
 
   heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
 
@@ skipping 55 matching lines @@
     CHECK(g4s1.IsWeak(iso));
     CHECK(g4s2.IsWeak(iso));
   }
 
   Persistent<Value> root(iso, g1s1);  // make a root.
 
   // Connect groups.  We're building the following cycle:
   // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other
   // groups.
   {
-    UniqueId id1(reinterpret_cast<intptr_t>(*g1s1));
-    UniqueId id2(reinterpret_cast<intptr_t>(*g2s1));
-    UniqueId id3(reinterpret_cast<intptr_t>(*g3s1));
-    UniqueId id4(reinterpret_cast<intptr_t>(*g4s1));
+    UniqueId id1 = MakeUniqueId(g1s1);
+    UniqueId id2 = MakeUniqueId(g2s1);
+    UniqueId id3 = MakeUniqueId(g3s1);
+    UniqueId id4 = MakeUniqueId(g4s1);
     iso->SetObjectGroupId(g1s1, id1);
     iso->SetObjectGroupId(g1s2, id1);
     iso->SetReferenceFromGroup(id1, g2s1);
     iso->SetObjectGroupId(g2s1, id2);
     iso->SetObjectGroupId(g2s2, id2);
     iso->SetReferenceFromGroup(id2, g3s1);
     iso->SetObjectGroupId(g3s1, id3);
     iso->SetObjectGroupId(g3s2, id3);
     iso->SetReferenceFromGroup(id3, g4s1);
     iso->SetObjectGroupId(g4s1, id4);
     iso->SetObjectGroupId(g4s2, id4);
     iso->SetReferenceFromGroup(id4, g1s1);
   }
   // Do a single full GC
   v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
       iso)->heap();
   heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
 
   // All object should be alive.
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
   root.MakeWeak(iso, &counter, &WeakPointerCallback);
 
   // Groups are deleted, rebuild groups.
   {
-    UniqueId id1(reinterpret_cast<intptr_t>(*g1s1));
-    UniqueId id2(reinterpret_cast<intptr_t>(*g2s1));
-    UniqueId id3(reinterpret_cast<intptr_t>(*g3s1));
-    UniqueId id4(reinterpret_cast<intptr_t>(*g4s1));
+    UniqueId id1 = MakeUniqueId(g1s1);
+    UniqueId id2 = MakeUniqueId(g2s1);
+    UniqueId id3 = MakeUniqueId(g3s1);
+    UniqueId id4 = MakeUniqueId(g4s1);
     iso->SetObjectGroupId(g1s1, id1);
     iso->SetObjectGroupId(g1s2, id1);
     iso->SetReferenceFromGroup(id1, g2s1);
     iso->SetObjectGroupId(g2s1, id2);
     iso->SetObjectGroupId(g2s2, id2);
     iso->SetReferenceFromGroup(id2, g3s1);
     iso->SetObjectGroupId(g3s1, id3);
     iso->SetObjectGroupId(g3s2, id3);
     iso->SetReferenceFromGroup(id3, g4s1);
     iso->SetObjectGroupId(g4s1, id4);
@@ skipping 54 matching lines @@
   {
     HandleScope handle_scope(iso);
     g1s1.MarkPartiallyDependent(iso);
     g1s2.MarkPartiallyDependent(iso);
     g2s1.MarkPartiallyDependent(iso);
     g2s2.MarkPartiallyDependent(iso);
     g3s1.MarkPartiallyDependent(iso);
     g3s2.MarkPartiallyDependent(iso);
     iso->SetObjectGroupId(g1s1, UniqueId(1));
     iso->SetObjectGroupId(g1s2, UniqueId(1));
-    Local<Object>::New(iso, g1s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g2s1));
+    Local<Object>::New(iso, g1s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g2s1));
     iso->SetObjectGroupId(g2s1, UniqueId(2));
     iso->SetObjectGroupId(g2s2, UniqueId(2));
-    Local<Object>::New(iso, g2s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g3s1));
+    Local<Object>::New(iso, g2s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g3s1));
     iso->SetObjectGroupId(g3s1, UniqueId(3));
     iso->SetObjectGroupId(g3s2, UniqueId(3));
-    Local<Object>::New(iso, g3s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g1s1));
+    Local<Object>::New(iso, g3s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g1s1));
   }
 
   v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
       iso)->heap();
   heap->CollectGarbage(i::NEW_SPACE);
 
   // All objects should be alive.
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
   root.MakeWeak(iso, &counter, &WeakPointerCallback);
   root.MarkPartiallyDependent(iso);
 
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   // Groups are deleted, rebuild groups.
   {
     HandleScope handle_scope(iso);
     g1s1.MarkPartiallyDependent(isolate);
     g1s2.MarkPartiallyDependent(isolate);
     g2s1.MarkPartiallyDependent(isolate);
     g2s2.MarkPartiallyDependent(isolate);
     g3s1.MarkPartiallyDependent(isolate);
     g3s2.MarkPartiallyDependent(isolate);
     iso->SetObjectGroupId(g1s1, UniqueId(1));
     iso->SetObjectGroupId(g1s2, UniqueId(1));
-    Local<Object>::New(iso, g1s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g2s1));
+    Local<Object>::New(iso, g1s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g2s1));
     iso->SetObjectGroupId(g2s1, UniqueId(2));
     iso->SetObjectGroupId(g2s2, UniqueId(2));
-    Local<Object>::New(iso, g2s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g3s1));
+    Local<Object>::New(iso, g2s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g3s1));
     iso->SetObjectGroupId(g3s1, UniqueId(3));
     iso->SetObjectGroupId(g3s2, UniqueId(3));
-    Local<Object>::New(iso, g3s1.As<Object>())->Set(v8_str("x"),
-                                                    Local<Value>(*g1s1));
+    Local<Object>::New(iso, g3s1.As<Object>())->Set(
+        v8_str("x"), Local<Value>::New(iso, g1s1));
   }
 
   heap->CollectGarbage(i::NEW_SPACE);
 
   // All objects should be gone. 7 global handles in total.
   CHECK_EQ(7, counter.NumberOfWeakCalls());
 }
 
 
 THREADED_TEST(ScriptException) {
@@ skipping 1432 matching lines @@
 THREADED_TEST(SimplePropertyWrite) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), GetXValue, SetXValue, v8_str("donut"));
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x = 4"));
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
     script->Run();
-    CHECK_EQ(v8_num(4), Handle<Value>(*xValue));
+    CHECK_EQ(v8_num(4), Local<Value>::New(v8::Isolate::GetCurrent(), xValue));
     xValue.Dispose(context->GetIsolate());
     xValue.Clear();
   }
 }
 
 
 THREADED_TEST(SetterOnly) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), NULL, SetXValue, v8_str("donut"));
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x = 4; obj.x"));
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
     script->Run();
-    CHECK_EQ(v8_num(4), Handle<Value>(*xValue));
+    CHECK_EQ(v8_num(4), Local<Value>::New(v8::Isolate::GetCurrent(), xValue));
     xValue.Dispose(context->GetIsolate());
     xValue.Clear();
   }
 }
 
 
 THREADED_TEST(NoAccessors) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"),
@@ skipping 204 matching lines @@
 
 
 Handle<v8::Array> UnboxedDoubleIndexedPropertyEnumerator(
     const AccessorInfo& info) {
   // Force the list of returned keys to be stored in a FastDoubleArray.
   Local<Script> indexed_property_names_script = Script::Compile(v8_str(
       "keys = new Array(); keys[125000] = 1;"
       "for(i = 0; i < 80000; i++) { keys[i] = i; };"
       "keys.length = 25; keys;"));
   Local<Value> result = indexed_property_names_script->Run();
-  return Local<v8::Array>(::v8::Array::Cast(*result));
+  return Local<v8::Array>::Cast(result);
 }
 
 
 // Make sure that the the interceptor code in the runtime properly handles
 // merging property name lists for double-array-backed arrays.
 THREADED_TEST(IndexedInterceptorUnboxedDoubleWithIndexedAccessor) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetIndexedPropertyHandler(UnboxedDoubleIndexedPropertyGetter,
                                    UnboxedDoubleIndexedPropertySetter,
@@ skipping 19 matching lines @@
 
 Handle<v8::Array> NonStrictArgsIndexedPropertyEnumerator(
     const AccessorInfo& info) {
   // Force the list of returned keys to be stored in a Arguments object.
   Local<Script> indexed_property_names_script = Script::Compile(v8_str(
       "function f(w,x) {"
       " return arguments;"
       "}"
       "keys = f(0, 1, 2, 3);"
       "keys;"));
-  Local<Value> result = indexed_property_names_script->Run();
-  return Local<v8::Array>(static_cast<v8::Array*>(::v8::Object::Cast(*result)));
+  Local<Object> result =
+      Local<Object>::Cast(indexed_property_names_script->Run());
+  return *reinterpret_cast<Local<v8::Array>*>(&result);
 }
 
 
 static v8::Handle<Value> NonStrictIndexedPropertyGetter(
     uint32_t index,
     const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
   if (index < 4) {
     return v8::Handle<Value>(v8_num(index));
   }
@@ skipping 1090 matching lines @@
   Snorkel() { index_ = global_index++; }
   int index_;
 };
 
 class Whammy {
  public:
   explicit Whammy(v8::Isolate* isolate) : cursor_(0), isolate_(isolate) { }
   ~Whammy() { script_.Dispose(isolate_); }
   v8::Handle<Script> getScript() {
     if (script_.IsEmpty()) script_.Reset(isolate_, v8_compile("({}).blammo"));
-    return Local<Script>(*script_);
+    return Local<Script>::New(isolate_, script_);
   }
 
  public:
   static const int kObjectCount = 256;
   int cursor_;
   v8::Isolate* isolate_;
   v8::Persistent<v8::Object> objects_[kObjectCount];
   v8::Persistent<Script> script_;
 };
 
@@ skipping 943 matching lines @@
   Handle<String> sym2 = v8::String::NewSymbol("\360\220\220\210");
   Handle<String> sym3 = v8::String::NewSymbol("x\355\240\201\355\260\207");
   Handle<String> sym4 = v8::String::NewSymbol("x\360\220\220\210");
   v8::Local<v8::Object> global = context->Global();
   Local<Value> s0 = global->Get(v8_str("sym0"));
   Local<Value> s0b = global->Get(v8_str("sym0b"));
   Local<Value> s1 = global->Get(v8_str("sym1"));
   Local<Value> s2 = global->Get(v8_str("sym2"));
   Local<Value> s3 = global->Get(v8_str("sym3"));
   Local<Value> s4 = global->Get(v8_str("sym4"));
-  CHECK(SameSymbol(sym0, Handle<String>(String::Cast(*s0))));
-  CHECK(SameSymbol(sym0b, Handle<String>(String::Cast(*s0b))));
-  CHECK(SameSymbol(sym1, Handle<String>(String::Cast(*s1))));
-  CHECK(SameSymbol(sym2, Handle<String>(String::Cast(*s2))));
-  CHECK(SameSymbol(sym3, Handle<String>(String::Cast(*s3))));
-  CHECK(SameSymbol(sym4, Handle<String>(String::Cast(*s4))));
+  CHECK(SameSymbol(sym0, Handle<String>::Cast(s0)));
+  CHECK(SameSymbol(sym0b, Handle<String>::Cast(s0b)));
+  CHECK(SameSymbol(sym1, Handle<String>::Cast(s1)));
+  CHECK(SameSymbol(sym2, Handle<String>::Cast(s2)));
+  CHECK(SameSymbol(sym3, Handle<String>::Cast(s3)));
+  CHECK(SameSymbol(sym4, Handle<String>::Cast(s4)));
 }
 
 
 THREADED_TEST(ToArrayIndex) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   v8::Handle<String> str = v8_str("42");
   v8::Handle<v8::Uint32> index = str->ToArrayIndex();
   CHECK(!index.IsEmpty());
@@ skipping 4968 matching lines @@
 void DisposingCallback(v8::Isolate* isolate,
                        v8::Persistent<v8::Value>* handle,
                        void*) {
   handle->Dispose(isolate);
 }
 
 void HandleCreatingCallback(v8::Isolate* isolate,
                             v8::Persistent<v8::Value>* handle,
                             void*) {
   v8::HandleScope scope(isolate);
-  v8::Persistent<v8::Object>::New(isolate, v8::Object::New());
+  v8::Persistent<v8::Object>(isolate, v8::Object::New());
   handle->Dispose(isolate);
 }
 
 
 THREADED_TEST(NoGlobalHandlesOrphaningDueToWeakCallback) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
 
   v8::Persistent<v8::Object> handle1, handle2, handle3;
   {
@@ skipping 7071 matching lines @@
   obj->GetIdentityHash();
   obj->DeleteHiddenValue(v8_str("Bug"));
 }
 
 
 THREADED_TEST(Regress2535) {
   i::FLAG_harmony_collections = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<Value> set_value = CompileRun("new Set();");
-  Local<Object> set_object(Object::Cast(*set_value));
+  Local<Object> set_object(Local<Object>::Cast(set_value));
   CHECK_EQ(0, set_object->InternalFieldCount());
   Local<Value> map_value = CompileRun("new Map();");
-  Local<Object> map_object(Object::Cast(*map_value));
+  Local<Object> map_object(Local<Object>::Cast(map_value));
   CHECK_EQ(0, map_object->InternalFieldCount());
 }
 
 
 #ifndef WIN32
 class ThreadInterruptTest {
  public:
   ThreadInterruptTest() : sem_(NULL), sem_value_(0) { }
   ~ThreadInterruptTest() { delete sem_; }
 
@@ skipping 47 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32