Remove deprecated APIs from cctest/test-feedback-vector

test/cctest/test-feedback-vector.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// TODO(mvstanton): Remove this define after this flag is turned on globally
+#define V8_IMMINENT_DEPRECATION_WARNINGS
+
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/api.h"
 #include "src/debug/debug.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "test/cctest/test-feedback-vector.h"
 
 using namespace v8::internal;
 
 namespace {
 
 #define CHECK_SLOT_KIND(helper, index, expected_kind) \
   CHECK_EQ(expected_kind, helper.vector()->GetKind(helper.slot(index)));
 
 
+static Handle<JSFunction> GetFunction(const char* name) {
+  v8::MaybeLocal<v8::Value> v8_f = CcTest::global()->Get(
+      v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str(name));
+  Handle<JSFunction> f =
+      Handle<JSFunction>::cast(v8::Utils::OpenHandle(*v8_f.ToLocalChecked()));
+  return f;
+}
+
+
 TEST(VectorStructure) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Zone* zone = isolate->runtime_zone();
 
   // Empty vectors are the empty fixed array.
   StaticFeedbackVectorSpec empty;
   Handle<TypeFeedbackVector> vector = NewTypeFeedbackVector(isolate, &empty);
@@ skipping 158 matching lines @@
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "function fun() {};"
       "function f(a) { a(); } f(fun);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = GetFunction("f");
   // There should be one IC.
   Handle<Code> code = handle(f->shared()->code(), isolate);
   TypeFeedbackInfo* feedback_info =
       TypeFeedbackInfo::cast(code->type_feedback_info());
   CHECK_EQ(1, feedback_info->ic_total_count());
   CHECK_EQ(0, feedback_info->ic_with_type_info_count());
   CHECK_EQ(0, feedback_info->ic_generic_count());
   Handle<TypeFeedbackVector> feedback_vector =
       handle(f->shared()->feedback_vector(), isolate);
   FeedbackVectorHelper helper(feedback_vector);
@@ skipping 33 matching lines @@
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "function foo() { return 17; }"
       "function f(a) { a(); } f(foo);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = GetFunction("f");
   // There should be one IC.
   Handle<TypeFeedbackVector> feedback_vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
   FeedbackVectorSlot slot(0);
   CallICNexus nexus(feedback_vector, slot);
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
   // CallIC doesn't return map feedback.
   CHECK(!nexus.FindFirstMap());
 
   CompileRun("f(function() { return 16; })");
@@ skipping 20 matching lines @@
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "var o = { foo: 3 };"
       "function f(a) { return a.foo; } f(o);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = GetFunction("f");
   // There should be one IC.
   Handle<TypeFeedbackVector> feedback_vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
   FeedbackVectorSlot slot(0);
   LoadICNexus nexus(feedback_vector, slot);
   CHECK_EQ(PREMONOMORPHIC, nexus.StateFromFeedback());
 
   CompileRun("f(o)");
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
   // Verify that the monomorphic map is the one we expect.
-  Handle<JSObject> o = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Object>::Cast(CcTest::global()->Get(v8_str("o"))));
+  v8::MaybeLocal<v8::Value> v8_o =
+      CcTest::global()->Get(context.local(), v8_str("o"));
+  Handle<JSObject> o =
+      Handle<JSObject>::cast(v8::Utils::OpenHandle(*v8_o.ToLocalChecked()));
   CHECK_EQ(o->map(), nexus.FindFirstMap());
 
   // Now go polymorphic.
   CompileRun("f({ blarg: 3, foo: 2 })");
   CHECK_EQ(POLYMORPHIC, nexus.StateFromFeedback());
 
   CompileRun(
       "delete o.foo;"
       "f(o)");
   CHECK_EQ(POLYMORPHIC, nexus.StateFromFeedback());
@@ skipping 24 matching lines @@
 
   // Function f has 3 LoadICs, one for each o, but the ICs share the same
   // feedback vector IC slot.
   CompileRun(
       "o = 10;"
       "function f() {"
       "  var x = o + 10;"
       "  return o + x + o;"
       "}"
       "f();");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = GetFunction("f");
   // There should be one IC slot.
   Handle<TypeFeedbackVector> feedback_vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
   FeedbackVectorHelper helper(feedback_vector);
   CHECK_EQ(1, helper.slot_count());
   FeedbackVectorSlot slot(0);
   LoadICNexus nexus(feedback_vector, slot);
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
 }
 
 
 TEST(VectorLoadICOnSmi) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun(
       "var o = { foo: 3 };"
       "function f(a) { return a.foo; } f(o);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = GetFunction("f");
   // There should be one IC.
   Handle<TypeFeedbackVector> feedback_vector =
       Handle<TypeFeedbackVector>(f->shared()->feedback_vector(), isolate);
   FeedbackVectorSlot slot(0);
   LoadICNexus nexus(feedback_vector, slot);
   CHECK_EQ(PREMONOMORPHIC, nexus.StateFromFeedback());
 
   CompileRun("f(34)");
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
   // Verify that the monomorphic map is the one we expect.
   Map* number_map = heap->heap_number_map();
   CHECK_EQ(number_map, nexus.FindFirstMap());
 
   // Now go polymorphic on o.
   CompileRun("f(o)");
   CHECK_EQ(POLYMORPHIC, nexus.StateFromFeedback());
 
   MapHandleList maps;
   nexus.FindAllMaps(&maps);
   CHECK_EQ(2, maps.length());
 
   // One of the maps should be the o map.
-  Handle<JSObject> o = v8::Utils::OpenHandle(
-      *v8::Handle<v8::Object>::Cast(CcTest::global()->Get(v8_str("o"))));
+  v8::MaybeLocal<v8::Value> v8_o =
+      CcTest::global()->Get(context.local(), v8_str("o"));
+  Handle<JSObject> o =
+      Handle<JSObject>::cast(v8::Utils::OpenHandle(*v8_o.ToLocalChecked()));
   bool number_map_found = false;
   bool o_map_found = false;
   for (int i = 0; i < maps.length(); i++) {
     Handle<Map> current = maps[i];
     if (*current == number_map)
       number_map_found = true;
     else if (*current == o->map())
       o_map_found = true;
   }
   CHECK(number_map_found && o_map_found);
 
   // The degree of polymorphism doesn't change.
   CompileRun("f(100)");
   CHECK_EQ(POLYMORPHIC, nexus.StateFromFeedback());
   MapHandleList maps2;
   nexus.FindAllMaps(&maps2);
   CHECK_EQ(2, maps2.length());
 }
 
 
-static Handle<JSFunction> GetFunction(const char* name) {
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str(name)))));
-  return f;
-}
-
-
 TEST(ReferenceContextAllocatesNoSlots) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Isolate* isolate = CcTest::i_isolate();
 
   {
     CompileRun(
         "function testvar(x) {"
@@ skipping 149 matching lines @@
   // There should be one IC slot.
   Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
   FeedbackVectorHelper helper(feedback_vector);
   CHECK_EQ(1, helper.slot_count());
   FeedbackVectorSlot slot(0);
   StoreICNexus nexus(feedback_vector, slot);
   CHECK_EQ(MONOMORPHIC, nexus.StateFromFeedback());
 }
 
 }  // namespace