Handlify Object::GetPrototype and (most) callers.

src/objects.cc

 // Copyright 2013 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 2946 matching lines @@
 
 MaybeHandle<Object> JSObject::SetElementWithCallbackSetterInPrototypes(
     Handle<JSObject> object,
     uint32_t index,
     Handle<Object> value,
     bool* found,
     StrictMode strict_mode) {
   Isolate *isolate = object->GetIsolate();
   for (Handle<Object> proto = handle(object->GetPrototype(), isolate);
        !proto->IsNull();
-       proto = handle(proto->GetPrototype(isolate), isolate)) {
+       proto = Object::GetPrototype(isolate, proto)) {
     if (proto->IsJSProxy()) {
       return JSProxy::SetPropertyViaPrototypesWithHandler(
           Handle<JSProxy>::cast(proto),
           object,
           isolate->factory()->Uint32ToString(index),  // name
           value,
           NONE,
           strict_mode,
           found);
     }
@@ skipping 448 matching lines @@
   LocalLookupRealNamedProperty(name, result);
   if (result->IsFound()) return;
 
   LookupRealNamedPropertyInPrototypes(name, result);
 }
 
 
 void JSObject::LookupRealNamedPropertyInPrototypes(Name* name,
                                                    LookupResult* result) {
   Isolate* isolate = GetIsolate();
-  Heap* heap = isolate->heap();
-  for (Object* pt = GetPrototype();
-       pt != heap->null_value();
-       pt = pt->GetPrototype(isolate)) {
+  DisallowHeapAllocation no_alloc;
+  for (Handle<Object> pt = handle(GetPrototype(), isolate);

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

No need to handlify. Especially since none of the callers of this method is
handlified either.

+       !pt->IsNull();
+       pt = Object::GetPrototype(isolate, pt)) {
     if (pt->IsJSProxy()) {
-      return result->HandlerResult(JSProxy::cast(pt));
+      return result->HandlerResult(JSProxy::cast(*pt));
     }
-    JSObject::cast(pt)->LocalLookupRealNamedProperty(name, result);
+    JSObject::cast(*pt)->LocalLookupRealNamedProperty(name, result);
     ASSERT(!(result->IsFound() && result->type() == INTERCEPTOR));
     if (result->IsFound()) return;
   }
   result->NotFound();
 }
 
 
 // We only need to deal with CALLBACKS and INTERCEPTORS
 MaybeHandle<Object> JSObject::SetPropertyWithFailedAccessCheck(
     Handle<JSObject> object,
@@ skipping 2967 matching lines @@
     }
     if (callback_obj->IsAccessorPair()) {
       return !AccessorPair::cast(callback_obj)->prohibits_overwriting();
     }
   }
   return true;
 }
 
 
 bool Map::DictionaryElementsInPrototypeChainOnly() {
-  Heap* heap = GetHeap();
+  Isolate* isolate = GetIsolate();
+  HandleScope scope(isolate);
+  DisallowHeapAllocation no_alloc;

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

No need to handlify.

 
   if (IsDictionaryElementsKind(elements_kind())) {
     return false;
   }
 
-  for (Object* prototype = this->prototype();
-       prototype != heap->null_value();
-       prototype = prototype->GetPrototype(GetIsolate())) {
+  for (Handle<Object> prototype(this->prototype(), isolate);
+       !prototype->IsNull();
+       prototype = Object::GetPrototype(isolate, prototype)) {
     if (prototype->IsJSProxy()) {
       // Be conservative, don't walk into proxies.
       return true;
     }
 
     if (IsDictionaryElementsKind(
-            JSObject::cast(prototype)->map()->elements_kind())) {
+            JSObject::cast(*prototype)->map()->elements_kind())) {
       return true;
     }
   }
 
   return false;
 }
 
 
 void JSObject::SetElementCallback(Handle<JSObject> object,
                                   uint32_t index,
@@ skipping 5527 matching lines @@
     Handle<Object> error = isolate->factory()->NewTypeError(
         "non_extensible_proto", HandleVector(args, ARRAY_SIZE(args)));
     isolate->Throw(*error);
     return Handle<Object>();
   }
 
   // Before we can set the prototype we need to be sure
   // prototype cycles are prevented.
   // It is sufficient to validate that the receiver is not in the new prototype
   // chain.
-  for (Object* pt = *value;
-       pt != heap->null_value();
-       pt = pt->GetPrototype(isolate)) {
-    if (JSReceiver::cast(pt) == *object) {
+  for (Handle<Object> pt = value;
+       !pt->IsNull();
+       pt = Object::GetPrototype(isolate, pt)) {
+    if (JSReceiver::cast(*pt) == *object) {

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

you could use
if (pt.is_identical_to(object)) { ... }

       // Cycle detected.
       Handle<Object> error = isolate->factory()->NewError(
           "cyclic_proto", HandleVector<Object>(NULL, 0));
       isolate->Throw(*error);
       return Handle<Object>();
     }
   }
 
   bool dictionary_elements_in_chain =
       object->map()->DictionaryElementsInPrototypeChainOnly();
   Handle<JSObject> real_receiver = object;
 
   if (skip_hidden_prototypes) {
     // Find the first object in the chain whose prototype object is not
     // hidden and set the new prototype on that object.
-    Object* current_proto = real_receiver->GetPrototype();
+    Handle<Object> current_proto(real_receiver->GetPrototype(), isolate);
     while (current_proto->IsJSObject() &&
-          JSObject::cast(current_proto)->map()->is_hidden_prototype()) {
-      real_receiver = handle(JSObject::cast(current_proto), isolate);
-      current_proto = current_proto->GetPrototype(isolate);
+          JSObject::cast(*current_proto)->map()->is_hidden_prototype()) {
+      real_receiver = handle(JSObject::cast(*current_proto));
+      current_proto = Object::GetPrototype(isolate, current_proto);
     }
   }
 
   // Set the new prototype of the object.
   Handle<Map> map(real_receiver->map());
 
   // Nothing to do if prototype is already set.
   if (map->prototype() == *value) return value;
 
   if (value->IsJSObject()) {
@@ skipping 4577 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal