Remove calls to non-handlified version of GetProperty(name).

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 275 matching lines @@
         factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
     function->set_initial_map(*initial_map);
     JSReceiver::SetProperty(global, name, function, NONE, SLOPPY).Check();
     // Allocate an object.  Unrooted after leaving the scope.
     Handle<JSObject> obj = factory->NewJSObject(function);
     JSReceiver::SetProperty(
         obj, prop_name, twenty_three, NONE, SLOPPY).Check();
     JSReceiver::SetProperty(
         obj, prop_namex, twenty_four, NONE, SLOPPY).Check();
 
-    CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));
-    CHECK_EQ(Smi::FromInt(24), obj->GetProperty(*prop_namex));
+    CHECK_EQ(Smi::FromInt(23), *Object::GetProperty(obj, prop_name));
+    CHECK_EQ(Smi::FromInt(24), *Object::GetProperty(obj, prop_namex));
   }
 
   heap->CollectGarbage(NEW_SPACE);
 
   // Function should be alive.
   CHECK(JSReceiver::HasLocalProperty(global, name));
   // Check function is retained.
-  Object* func_value = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*name)->ToObjectChecked();
+  Handle<Object> func_value = Object::GetProperty(global, name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
 
   {
     HandleScope inner_scope(isolate);
     // Allocate another object, make it reachable from global.
     Handle<JSObject> obj = factory->NewJSObject(function);
     JSReceiver::SetProperty(global, obj_name, obj, NONE, SLOPPY).Check();
     JSReceiver::SetProperty(
         obj, prop_name, twenty_three, NONE, SLOPPY).Check();
   }
 
   // After gc, it should survive.
   heap->CollectGarbage(NEW_SPACE);
 
   CHECK(JSReceiver::HasLocalProperty(global, obj_name));
-  CHECK(CcTest::i_isolate()->context()->global_object()->
-        GetProperty(*obj_name)->ToObjectChecked()->IsJSObject());
-  Object* obj = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*obj_name)->ToObjectChecked();
-  JSObject* js_obj = JSObject::cast(obj);
-  CHECK_EQ(Smi::FromInt(23), js_obj->GetProperty(*prop_name));
+  Handle<Object> obj = Object::GetProperty(global, obj_name);
+  CHECK(obj->IsJSObject());
+  CHECK_EQ(Smi::FromInt(23), *Object::GetProperty(obj, prop_name));
 }
 
 
 static void VerifyStringAllocation(Isolate* isolate, const char* string) {
   HandleScope scope(isolate);
   Handle<String> s = isolate->factory()->NewStringFromUtf8(CStrVector(string));
   CHECK_EQ(StrLength(string), s->length());
   for (int index = 0; index < s->length(); index++) {
     CHECK_EQ(static_cast<uint16_t>(string[index]), s->Get(index));
   }
@@ skipping 303 matching lines @@
   Handle<Map> initial_map =
       factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
   function->set_initial_map(*initial_map);
 
   Handle<Smi> twenty_three(Smi::FromInt(23), isolate);
   Handle<Smi> twenty_four(Smi::FromInt(24), isolate);
 
   Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");
   Handle<JSObject> obj = factory->NewJSObject(function);
   JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, SLOPPY).Check();
-  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));
+  CHECK_EQ(Smi::FromInt(23), *Object::GetProperty(obj, prop_name));
   // Check that we can add properties to function objects.
   JSReceiver::SetProperty(
       function, prop_name, twenty_four, NONE, SLOPPY).Check();
-  CHECK_EQ(Smi::FromInt(24), function->GetProperty(*prop_name));
+  CHECK_EQ(Smi::FromInt(24), *Object::GetProperty(function, prop_name));
 }
 
 
 TEST(ObjectProperties) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   v8::HandleScope sc(CcTest::isolate());
-  String* object_string = String::cast(CcTest::heap()->Object_string());
-  Object* raw_object = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(object_string)->ToObjectChecked();
-  JSFunction* object_function = JSFunction::cast(raw_object);
-  Handle<JSFunction> constructor(object_function);
+  Handle<String> object_string(String::cast(CcTest::heap()->Object_string()));
+  Handle<Object> object =
+      Object::GetProperty(CcTest::i_isolate()->global_object(), object_string);
+  Handle<JSFunction> constructor = Handle<JSFunction>::cast(object);
   Handle<JSObject> obj = factory->NewJSObject(constructor);
   Handle<String> first = factory->InternalizeUtf8String("first");
   Handle<String> second = factory->InternalizeUtf8String("second");
 
   Handle<Smi> one(Smi::FromInt(1), isolate);
   Handle<Smi> two(Smi::FromInt(2), isolate);
 
   // check for empty
   CHECK(!JSReceiver::HasLocalProperty(obj, first));
 
@@ skipping 59 matching lines @@
   Handle<Map> initial_map =
       factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
   function->set_initial_map(*initial_map);
 
   Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");
   Handle<JSObject> obj = factory->NewJSObject(function);
 
   // Set a propery
   Handle<Smi> twenty_three(Smi::FromInt(23), isolate);
   JSReceiver::SetProperty(obj, prop_name, twenty_three, NONE, SLOPPY).Check();
-  CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));
+  CHECK_EQ(Smi::FromInt(23), *Object::GetProperty(obj, prop_name));
 
   // Check the map has changed
   CHECK(*initial_map != obj->map());
 }
 
 
 TEST(JSArray) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   v8::HandleScope sc(CcTest::isolate());
   Handle<String> name = factory->InternalizeUtf8String("Array");
-  Object* raw_object = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*name)->ToObjectChecked();
-  Handle<JSFunction> function = Handle<JSFunction>(
-      JSFunction::cast(raw_object));
+  Handle<Object> fun_obj =
+      Object::GetProperty(CcTest::i_isolate()->global_object(), name);
+  Handle<JSFunction> function = Handle<JSFunction>::cast(fun_obj);
 
   // Allocate the object.
   Handle<JSObject> object = factory->NewJSObject(function);
   Handle<JSArray> array = Handle<JSArray>::cast(object);
   // We just initialized the VM, no heap allocation failure yet.
   JSArray::Initialize(array, 0);
 
   // Set array length to 0.
   *JSArray::SetElementsLength(array, handle(Smi::FromInt(0), isolate));
   CHECK_EQ(Smi::FromInt(0), array->length());
@@ skipping 24 matching lines @@
   CHECK_EQ(*i::Object::GetElement(isolate, array, 0), *name);
 }
 
 
 TEST(JSObjectCopy) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   v8::HandleScope sc(CcTest::isolate());
-  String* object_string = String::cast(CcTest::heap()->Object_string());
-  Object* raw_object = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(object_string)->ToObjectChecked();
-  JSFunction* object_function = JSFunction::cast(raw_object);
-  Handle<JSFunction> constructor(object_function);
+  Handle<String> object_string(String::cast(CcTest::heap()->Object_string()));
+  Handle<Object> object =
+      Object::GetProperty(CcTest::i_isolate()->global_object(), object_string);
+  Handle<JSFunction> constructor = Handle<JSFunction>::cast(object);
   Handle<JSObject> obj = factory->NewJSObject(constructor);
   Handle<String> first = factory->InternalizeUtf8String("first");
   Handle<String> second = factory->InternalizeUtf8String("second");
 
   Handle<Smi> one(Smi::FromInt(1), isolate);
   Handle<Smi> two(Smi::FromInt(2), isolate);
 
   JSReceiver::SetProperty(obj, first, one, NONE, SLOPPY).Check();
   JSReceiver::SetProperty(obj, second, two, NONE, SLOPPY).Check();
 
   JSReceiver::SetElement(obj, 0, first, NONE, SLOPPY).Check();
   JSReceiver::SetElement(obj, 1, second, NONE, SLOPPY).Check();
 
   // Make the clone.
   Handle<JSObject> clone = JSObject::Copy(obj);
   CHECK(!clone.is_identical_to(obj));
 
   CHECK_EQ(*i::Object::GetElement(isolate, obj, 0),
            *i::Object::GetElement(isolate, clone, 0));
   CHECK_EQ(*i::Object::GetElement(isolate, obj, 1),
            *i::Object::GetElement(isolate, clone, 1));
 
-  CHECK_EQ(obj->GetProperty(*first), clone->GetProperty(*first));
-  CHECK_EQ(obj->GetProperty(*second), clone->GetProperty(*second));
+  CHECK_EQ(*Object::GetProperty(obj, first),
+           *Object::GetProperty(clone, first));
+  CHECK_EQ(*Object::GetProperty(obj, second),
+           *Object::GetProperty(clone, second));
 
   // Flip the values.
   JSReceiver::SetProperty(clone, first, two, NONE, SLOPPY).Check();
   JSReceiver::SetProperty(clone, second, one, NONE, SLOPPY).Check();
 
   JSReceiver::SetElement(clone, 0, second, NONE, SLOPPY).Check();
   JSReceiver::SetElement(clone, 1, first, NONE, SLOPPY).Check();
 
   CHECK_EQ(*i::Object::GetElement(isolate, obj, 1),
            *i::Object::GetElement(isolate, clone, 0));
   CHECK_EQ(*i::Object::GetElement(isolate, obj, 0),
            *i::Object::GetElement(isolate, clone, 1));
 
-  CHECK_EQ(obj->GetProperty(*second), clone->GetProperty(*first));
-  CHECK_EQ(obj->GetProperty(*first), clone->GetProperty(*second));
+  CHECK_EQ(*Object::GetProperty(obj, second),
+           *Object::GetProperty(clone, first));
+  CHECK_EQ(*Object::GetProperty(obj, first),
+           *Object::GetProperty(clone, second));
 }
 
 
 TEST(StringAllocation) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   const unsigned char chars[] = { 0xe5, 0xa4, 0xa7 };
   for (int length = 0; length < 100; length++) {
@@ skipping 198 matching lines @@
                        "};"
                        "foo()";
   Handle<String> foo_name = factory->InternalizeUtf8String("foo");
 
   // This compile will add the code to the compilation cache.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun(source);
   }
 
   // Check function is compiled.
-  Object* func_value = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*foo_name)->ToObjectChecked();
+  Handle<Object> func_value =
+      Object::GetProperty(CcTest::i_isolate()->global_object(), foo_name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
   CHECK(function->shared()->is_compiled());
 
   // The code will survive at least two GCs.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Simulate several GCs that use full marking.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
     CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   }
 
   // foo should no longer be in the compilation cache
   CHECK(!function->shared()->is_compiled() || function->IsOptimized());
   CHECK(!function->is_compiled() || function->IsOptimized());
   // Call foo to get it recompiled.
   CompileRun("foo()");
   CHECK(function->shared()->is_compiled());
   CHECK(function->is_compiled());
 }
 
 
 TEST(TestCodeFlushingPreAged) {
   // If we do not flush code this test is invalid.
   if (!FLAG_flush_code) return;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_optimize_for_size = true;
   CcTest::InitializeVM();
-  Isolate* isolate = Isolate::Current();
+  Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
   const char* source = "function foo() {"
                        "  var x = 42;"
                        "  var y = 42;"
                        "  var z = x + y;"
                        "};"
                        "foo()";
   Handle<String> foo_name = factory->InternalizeUtf8String("foo");
 
   // Compile foo, but don't run it.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun(source);
   }
 
   // Check function is compiled.
-  Object* func_value = Isolate::Current()->context()->global_object()->
-      GetProperty(*foo_name)->ToObjectChecked();
+  Handle<Object> func_value =
+      Object::GetProperty(isolate->global_object(), foo_name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
   CHECK(function->shared()->is_compiled());
 
   // The code has been run so will survive at least one GC.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // The code was only run once, so it should be pre-aged and collected on the
   // next GC.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(!function->shared()->is_compiled() || function->IsOptimized());
@@ skipping 41 matching lines @@
                        "};"
                        "foo()";
   Handle<String> foo_name = factory->InternalizeUtf8String("foo");
 
   // This compile will add the code to the compilation cache.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun(source);
   }
 
   // Check function is compiled.
-  Object* func_value = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*foo_name)->ToObjectChecked();
+  Handle<Object> func_value =
+      Object::GetProperty(isolate->global_object(), foo_name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
   CHECK(function->shared()->is_compiled());
 
   // The code will survive at least two GCs.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Simulate several GCs that use incremental marking.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
@@ skipping 53 matching lines @@
 
   // Perfrom one initial GC to enable code flushing.
   CcTest::heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
 
   // This compile will add the code to the compilation cache.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun(source);
   }
 
   // Check functions are compiled.
-  Object* func_value = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*foo_name)->ToObjectChecked();
+  Handle<Object> func_value =
+      Object::GetProperty(isolate->global_object(), foo_name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
   CHECK(function->shared()->is_compiled());
-  Object* func_value2 = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*bar_name)->ToObjectChecked();
+  Handle<Object> func_value2 =
+      Object::GetProperty(isolate->global_object(), bar_name);
   CHECK(func_value2->IsJSFunction());
-  Handle<JSFunction> function2(JSFunction::cast(func_value2));
+  Handle<JSFunction> function2 = Handle<JSFunction>::cast(func_value2);
   CHECK(function2->shared()->is_compiled());
 
   // Clear references to functions so that one of them can die.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun("foo = 0; bar = 0;");
   }
 
   // Bump the code age so that flushing is triggered while the function
   // object is still located in new-space.
   const int kAgingThreshold = 6;
@@ skipping 33 matching lines @@
                        "};"
                        "foo()";
   Handle<String> foo_name = factory->InternalizeUtf8String("foo");
 
   // This compile will add the code to the compilation cache.
   { v8::HandleScope scope(CcTest::isolate());
     CompileRun(source);
   }
 
   // Check function is compiled.
-  Object* func_value = CcTest::i_isolate()->context()->global_object()->
-      GetProperty(*foo_name)->ToObjectChecked();
+  Handle<Object> func_value =
+      Object::GetProperty(isolate->global_object(), foo_name);
   CHECK(func_value->IsJSFunction());
-  Handle<JSFunction> function(JSFunction::cast(func_value));
+  Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
   CHECK(function->shared()->is_compiled());
 
   // The code will survive at least two GCs.
   heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Bump the code age so that flushing is triggered.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
@@ skipping 2595 matching lines @@
   v8::Context::Scope cscope(context);
 
   v8::Local<v8::Value> result = CompileRun(
       "var locals = '';"
       "for (var i = 0; i < 512; i++) locals += 'var v' + i + '= 42;';"
       "eval('function f() {' + locals + 'return function() { return v0; }; }');"
       "interrupt();"  // This triggers a fake stack overflow in f.
       "f()()");
   CHECK_EQ(42.0, result->ToNumber()->Value());
 }