Map v8::Function to JSReceiver + IsCallable

test/cctest/test-heap.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 2555 matching lines @@
         "function g () { f(mkbar()); }"
         "f(new foo()); f(new foo());"
         "%OptimizeFunctionOnNextCall(f);"
         "f(new foo()); g();");
   }
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
   CcTest::heap()->StartIncrementalMarking();
 
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   CHECK(f->IsOptimized());
 
   while (!Marking::IsBlack(Marking::MarkBitFrom(f->code())) &&
          !marking->IsStopped()) {
     // Discard any pending GC requests otherwise we will get GC when we enter
     // code below.
     marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   }
 
@@ skipping 94 matching lines @@
     CompileRun(
         "function f () {"
         "  var s = 0;"
         "  for (var i = 0; i < 100; i++)  s += i;"
         "  return s;"
         "}"
         "f(); f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
   }
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
   CHECK(f->IsOptimized());
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
   CcTest::heap()->StartIncrementalMarking();
   // The following calls will increment CcTest::heap()->global_ic_age().
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
@@ skipping 18 matching lines @@
     CompileRun(
         "function f () {"
         "  var s = 0;"
         "  for (var i = 0; i < 100; i++)  s += i;"
         "  return s;"
         "}"
         "f(); f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
   }
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
   CHECK(f->IsOptimized());
 
   CcTest::heap()->incremental_marking()->Stop();
 
   // The following two calls will increment CcTest::heap()->global_ic_age().
   CcTest::isolate()->ContextDisposedNotification();
   CcTest::heap()->CollectAllGarbage();
 
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
@@ skipping 863 matching lines @@
 }
 
 
 #ifdef OBJECT_PRINT
 TEST(PrintSharedFunctionInfo) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   const char* source = "f = function() { return 987654321; }\n"
                        "g = function() { return 123456789; }\n";
   CompileRun(source);
-  Handle<JSFunction> g =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("g"))));
+  Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
 
   OFStream os(stdout);
   g->shared()->Print(os);
   os << std::endl;
 }
 #endif  // OBJECT_PRINT
 
 
 TEST(IncrementalMarkingPreservesMonomorphicCallIC) {
   if (i::FLAG_always_opt) return;
@@ skipping 12 matching lines @@
     CompileRun("function fun() {};");
     fun2 = env->Global()->Get(v8_str("fun"));
   }
 
   // Prepare function f that contains type feedback for closures
   // originating from two different native contexts.
   CcTest::global()->Set(v8_str("fun1"), fun1);
   CcTest::global()->Set(v8_str("fun2"), fun2);
   CompileRun("function f(a, b) { a(); b(); } f(fun1, fun2);");
 
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
   FeedbackVectorHelper feedback_helper(feedback_vector);
 
   int expected_slots = 2;
   CHECK_EQ(expected_slots, feedback_helper.slot_count());
   int slot1 = 0;
   int slot2 = 1;
   CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakCell());
   CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakCell());
@@ skipping 85 matching lines @@
 TEST(IncrementalMarkingPreservesMonomorphicConstructor) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun(
       "function fun() { this.x = 1; };"
       "function f(o) { return new o(); } f(fun); f(fun);");
-  Handle<JSFunction> f = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
 
   Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 }
@@ skipping 11 matching lines @@
     CompileRun("function fun() { this.x = 1; };");
     fun1 = env->Global()->Get(v8_str("fun"));
   }
 
   // Prepare function f that contains a monomorphic constructor for object
   // originating from a different native context.
   CcTest::global()->Set(v8_str("fun1"), fun1);
   CompileRun(
       "function fun() { this.x = 1; };"
       "function f(o) { return new o(); } f(fun1); f(fun1);");
-  Handle<JSFunction> f = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
 
   Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CHECK_EQ(*TypeFeedbackVector::UninitializedSentinel(isolate),
            vector->Get(FeedbackVectorSlot(0)));
 }
 
 
 TEST(IncrementalMarkingPreservesMonomorphicIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun("function fun() { this.x = 1; }; var obj = new fun();"
              "function f(o) { return o.x; } f(obj); f(obj);");
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CheckVectorIC(f, 0, MONOMORPHIC);
   CHECK(ic_before->ic_state() == DEFAULT);
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CheckVectorIC(f, 0, MONOMORPHIC);
@@ skipping 10 matching lines @@
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
     obj1 = env->Global()->Get(v8_str("obj"));
   }
 
   // Prepare function f that contains a monomorphic IC for object
   // originating from a different native context.
   CcTest::global()->Set(v8_str("obj1"), obj1);
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1);");
-  Handle<JSFunction> f = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CheckVectorIC(f, 0, MONOMORPHIC);
   CHECK(ic_before->ic_state() == DEFAULT);
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
@@ skipping 19 matching lines @@
     LocalContext env;
     CompileRun("function fun() { this.x = 2; }; var obj = new fun();");
     obj2 = env->Global()->Get(v8_str("obj"));
   }
 
   // Prepare function f that contains a polymorphic IC for objects
   // originating from two different native contexts.
   CcTest::global()->Set(v8_str("obj1"), obj1);
   CcTest::global()->Set(v8_str("obj2"), obj2);
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1); f(obj2);");
-  Handle<JSFunction> f = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CheckVectorIC(f, 0, POLYMORPHIC);
   CHECK(ic_before->ic_state() == DEFAULT);
 
   // Fire context dispose notification.
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
@@ skipping 18 matching lines @@
     LocalContext env;
     CompileRun("function fun() { this.x = 2; }; var obj = new fun();");
     obj2 = env->Global()->Get(v8_str("obj"));
   }
 
   // Prepare function f that contains a polymorphic IC for objects
   // originating from two different native contexts.
   CcTest::global()->Set(v8_str("obj1"), obj1);
   CcTest::global()->Set(v8_str("obj2"), obj2);
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1); f(obj2);");
-  Handle<JSFunction> f = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   Code* ic_before = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CheckVectorIC(f, 0, POLYMORPHIC);
   CHECK(ic_before->ic_state() == DEFAULT);
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
@@ skipping 134 matching lines @@
                "  return function(x) { return x + 1; };"
                "}"
                "var f = mkClosure();"
                "var g = mkClosure();"
                "f(1); f(2);"
                "g(1); g(2);"
                "h(1); h(2);"
                "%OptimizeFunctionOnNextCall(f); f(3);"
                "%OptimizeFunctionOnNextCall(h); h(3);");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("f"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
     CHECK(f->is_compiled());
     CompileRun("f = null;");
 
-    Handle<JSFunction> g =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("g"))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
     CHECK(g->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       g->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     code = inner_scope.CloseAndEscape(Handle<Code>(f->code()));
   }
 
   // Simulate incremental marking so that the functions are enqueued as
@@ skipping 23 matching lines @@
   // but make sure the optimized code is unreachable.
   {
     HandleScope inner_scope(isolate);
     CompileRun("function mkClosure() {"
                "  return function(x) { return x + 1; };"
                "}"
                "var f = mkClosure();"
                "f(1); f(2);"
                "%OptimizeFunctionOnNextCall(f); f(3);");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("f"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     CompileRun("f = null;");
   }
 
   // Simulate incremental marking so that unoptimized code is flushed
@@ skipping 23 matching lines @@
   // the unoptimized code will be replaced during optimization.
   Handle<SharedFunctionInfo> shared1;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function f() { return 'foobar'; }"
                "function g(x) { if (x) f(); }"
                "f();"
                "g(false);"
                "g(false);");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("f"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     shared1 = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
   }
 
   // Prepare a shared function info eligible for code flushing that will
   // represent the dangling tail of the candidate list.
   Handle<SharedFunctionInfo> shared2;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function flushMe() { return 0; }"
                "flushMe(1);");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("flushMe"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
+            CcTest::global()->Get(v8_str("flushMe")))));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     shared2 = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
   }
 
   // Simulate incremental marking and collect code flushing candidates.
@@ skipping 95 matching lines @@
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Prepare function whose optimized code map we can use.
   Handle<SharedFunctionInfo> shared;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function f() { return 1 }"
                "f(); %OptimizeFunctionOnNextCall(f); f();");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("f"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
     shared = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
     CompileRun("f = null");
   }
 
   // Prepare optimized code that we can use.
   Handle<Code> code;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function g() { return 2 }"
                "g(); %OptimizeFunctionOnNextCall(g); g();");
 
-    Handle<JSFunction> g =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("g"))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
     code = inner_scope.CloseAndEscape(handle(g->code(), isolate));
     if (!code->is_optimized_code()) return;
   }
 
   Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
   Handle<LiteralsArray> lit =
       LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
   Handle<Context> context(isolate->context());
 
   // Add the new code several times to the optimized code map and also set an
@@ skipping 19 matching lines @@
   // Perfrom one initial GC to enable code flushing.
   CcTest::heap()->CollectAllGarbage();
 
   // Prepare function whose optimized code map we can use.
   Handle<SharedFunctionInfo> shared;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function f() { return 1 }"
                "f(); %OptimizeFunctionOnNextCall(f); f();");
 
-    Handle<JSFunction> f =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("f"))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
     shared = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
     CompileRun("f = null");
   }
 
   // Prepare optimized code that we can use.
   Handle<Code> code;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function g() { return 2 }"
                "g(); %OptimizeFunctionOnNextCall(g); g();");
 
-    Handle<JSFunction> g =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("g"))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
     code = inner_scope.CloseAndEscape(handle(g->code(), isolate));
     if (!code->is_optimized_code()) return;
   }
 
   Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
   Handle<LiteralsArray> lit =
       LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
   Handle<Context> context(isolate->context());
 
   // Add the code several times to the optimized code map.
@@ skipping 203 matching lines @@
             AllocationSite::cast(heap->allocation_sites_list())));
 
     CompileRun("%OptimizeFunctionOnNextCall(bar); bar();");
 
     DependentCode::GroupStartIndexes starts(site->dependent_code());
     CHECK_GE(starts.number_of_entries(), 1);
     int index = starts.at(DependentCode::kAllocationSiteTransitionChangedGroup);
     CHECK(site->dependent_code()->object_at(index)->IsWeakCell());
     Code* function_bar = Code::cast(
         WeakCell::cast(site->dependent_code()->object_at(index))->value());
-    Handle<JSFunction> bar_handle =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("bar"))));
+    Handle<JSFunction> bar_handle = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
+            CcTest::global()->Get(v8_str("bar")))));
     CHECK_EQ(bar_handle->code(), function_bar);
   }
 
   // Now make sure that a gc should get rid of the function, even though we
   // still have the allocation site alive.
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   // The site still exists because of our global handle, but the code is no
@@ skipping 25 matching lines @@
                "    return foo(1);"
                "  };"
                "  var foo = function(x) { with (x) { return 1 + x; } };"
                "  bar(foo);"
                "  bar(foo);"
                "  bar(foo);"
                "  %OptimizeFunctionOnNextCall(bar);"
                "  bar(foo);"
                "  return bar;})();");
 
-    Handle<JSFunction> bar =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("bar"))));
+    Handle<JSFunction> bar = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("bar")))));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   DCHECK(code->marked_for_deoptimization());
 }
@@ skipping 17 matching lines @@
     CompileRun("function bar() {"
                "  return foo(1);"
                "};"
                "function foo(x) { with (x) { return 1 + x; } };"
                "bar();"
                "bar();"
                "bar();"
                "%OptimizeFunctionOnNextCall(bar);"
                "bar();");
 
-    Handle<JSFunction> bar =
-        v8::Utils::OpenHandle(
-            *v8::Handle<v8::Function>::Cast(
-                CcTest::global()->Get(v8_str("bar"))));
+    Handle<JSFunction> bar = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("bar")))));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   DCHECK(code->marked_for_deoptimization());
 }
@@ skipping 51 matching lines @@
 
 
 static Handle<JSFunction> OptimizeDummyFunction(const char* name) {
   EmbeddedVector<char, 256> source;
   SNPrintF(source,
           "function %s() { return 0; }"
           "%s(); %s();"
           "%%OptimizeFunctionOnNextCall(%s);"
           "%s();", name, name, name, name, name);
   CompileRun(source.start());
-  Handle<JSFunction> fun =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str(name))));
+  Handle<JSFunction> fun = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str(name)))));
   return fun;
 }
 
 
 static int GetCodeChainLength(Code* code) {
   int result = 0;
   while (code->next_code_link()->IsCode()) {
     result++;
     code = Code::cast(code->next_code_link());
   }
@@ skipping 85 matching lines @@
 TEST(WeakFunctionInConstructor) {
   if (i::FLAG_always_opt) return;
   i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   CompileRun(
       "function createObj(obj) {"
       "  return new obj();"
       "}");
-  Handle<JSFunction> createObj =
+  Handle<JSFunction> createObj = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
-                                CcTest::global()->Get(v8_str("createObj"))));
+          CcTest::global()->Get(v8_str("createObj")))));
 
   v8::Persistent<v8::Object> garbage;
   {
     v8::HandleScope scope(isolate);
     const char* source =
         " (function() {"
         "   function hat() { this.x = 5; }"
         "   createObj(hat);"
         "   createObj(hat);"
         "   return hat;"
@@ skipping 984 matching lines @@
 
   CHECK(utils_has_been_collected);
 }
 
 
 TEST(Regress1878) {
   FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Local<v8::Function> constructor =
-      v8::Utils::ToLocal(CcTest::i_isolate()->internal_array_function());
+  v8::Local<v8::Function> constructor = v8::Utils::FunctionToLocal(
+      CcTest::i_isolate()->internal_array_function());
   CcTest::global()->Set(v8_str("InternalArray"), constructor);
 
   v8::TryCatch try_catch(isolate);
 
   CompileRun(
       "var a = Array();"
       "for (var i = 0; i < 1000; i++) {"
       "  var ai = new InternalArray(10000);"
       "  if (%HaveSameMap(ai, a)) throw Error();"
       "  if (!%HasFastObjectElements(ai)) throw Error();"
@@ skipping 384 matching lines @@
   // The CollectGarbage call above starts sweeper threads.
   // The crash will happen if the following two functions
   // are called before sweeping finishes.
   heap->StartIncrementalMarking();
   heap->FinalizeIncrementalMarkingIfComplete("test");
 }
 
 
 }  // namespace internal
 }  // namespace v8