Handlify Object::GetPrototype and (most) callers.

src/runtime.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 4881 matching lines @@
   // Handle [] indexing on String objects
   if (object->IsStringObjectWithCharacterAt(index)) {
     Handle<JSValue> js_value = Handle<JSValue>::cast(object);
     Handle<Object> result =
         GetCharAt(Handle<String>(String::cast(js_value->value())), index);
     if (!result->IsUndefined()) return result;
   }
 
   Handle<Object> result;
   if (object->IsString() || object->IsNumber() || object->IsBoolean()) {
-    Handle<Object> proto(object->GetPrototype(isolate), isolate);
+    Handle<Object> proto = Object::GetPrototype(isolate, object);
     return Object::GetElement(isolate, proto, index);
   } else {
     return Object::GetElement(isolate, object, index);
   }
 }
 
 
 MUST_USE_RESULT
 static MaybeHandle<Name> ToName(Isolate* isolate, Handle<Object> key) {
   if (key->IsName()) {
@@ skipping 5703 matching lines @@
 // Intervals can span over some keys that are not in the object.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetArrayKeys) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, array, 0);
   CONVERT_NUMBER_CHECKED(uint32_t, length, Uint32, args[1]);
   if (array->elements()->IsDictionary()) {
     Handle<FixedArray> keys = isolate->factory()->empty_fixed_array();
     for (Handle<Object> p = array;
          !p->IsNull();
-         p = Handle<Object>(p->GetPrototype(isolate), isolate)) {
+         p = Object::GetPrototype(isolate, p)) {
       if (p->IsJSProxy() || JSObject::cast(*p)->HasIndexedInterceptor()) {
         // Bail out if we find a proxy or interceptor, likely not worth
         // collecting keys in that case.
         return *isolate->factory()->NewNumberFromUint(length);
       }
       Handle<JSObject> current = Handle<JSObject>::cast(p);
       Handle<FixedArray> current_keys =
           isolate->factory()->NewFixedArray(
               current->NumberOfLocalElements(NONE));
       current->GetLocalElementKeys(*current_keys, NONE);
@@ skipping 2181 matching lines @@
   RETURN_IF_EMPTY_HANDLE(isolate, eval_fun);
 
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       Execution::Call(isolate, eval_fun, receiver, 0, NULL));
 
   // Skip the global proxy as it has no properties and always delegates to the
   // real global object.
   if (result->IsJSGlobalProxy()) {
-    result = Handle<JSObject>(JSObject::cast(result->GetPrototype(isolate)));
+    Handle<Object> proto = Object::GetPrototype(isolate, result);
+    result = handle(JSObject::cast(*proto));

[Yang, 2014/04/15 13:10:48]

Use Handle<JSObject>::cast here. That will not create a new handle on the handle
stack.

   }
 
   // Clear the oneshot breakpoints so that the debugger does not step further.
   isolate->debug()->ClearStepping();
   return *result;
 }
 
 
 // Evaluate a piece of JavaScript in the context of a stack frame for
 // debugging.  Things that need special attention are:
@@ skipping 134 matching lines @@
 }
 
 
 // Helper function used by Runtime_DebugReferencedBy below.
 static int DebugReferencedBy(HeapIterator* iterator,
                              JSObject* target,
                              Object* instance_filter, int max_references,
                              FixedArray* instances, int instances_size,
                              JSFunction* arguments_function) {
   Isolate* isolate = target->GetIsolate();
-  SealHandleScope shs(isolate);
+  HandleScope shs(isolate);
   DisallowHeapAllocation no_allocation;
 
   // Iterate the heap.
   int count = 0;
   JSObject* last = NULL;
   HeapObject* heap_obj = NULL;
   while (((heap_obj = iterator->next()) != NULL) &&
          (max_references == 0 || count < max_references)) {
     // Only look at all JSObjects.
     if (heap_obj->IsJSObject()) {
       // Skip context extension objects and argument arrays as these are
       // checked in the context of functions using them.
       JSObject* obj = JSObject::cast(heap_obj);
       if (obj->IsJSContextExtensionObject() ||
           obj->map()->constructor() == arguments_function) {
         continue;
       }
 
       // Check if the JS object has a reference to the object looked for.
       if (obj->ReferencesObject(target)) {
         // Check instance filter if supplied. This is normally used to avoid
         // references from mirror objects (see Runtime_IsInPrototypeChain).
         if (!instance_filter->IsUndefined()) {
           Object* V = obj;
           while (true) {
-            Object* prototype = V->GetPrototype(isolate);
+            Object* prototype =
+                *Object::GetPrototype(isolate, handle(V, isolate));

[Yang, 2014/04/15 13:10:48]

This function is not handlified. Please don't do it in part.

             if (prototype->IsNull()) {
               break;
             }
             if (instance_filter == prototype) {
               obj = NULL;  // Don't add this object.
               break;
             }
             V = prototype;
           }
         }
@@ skipping 2088 matching lines @@
   }
 }
 
 
 void Runtime::OutOfMemory() {
   Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true);
   UNREACHABLE();
 }
 
 } }  // namespace v8::internal