Clean up some "GetProperty" methods/functions.

src/json-stringifier.h

 // 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 639 matching lines @@
   }
 
   Append('{');
   bool comma = false;
 
   if (object->HasFastProperties() &&
       !object->HasIndexedInterceptor() &&
       !object->HasNamedInterceptor() &&
       object->elements()->length() == 0) {
     Handle<Map> map(object->map());
     for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {

[Igor Sheludko, 2014/03/26 18:37:31]

Shouldn't we create a HandleScope here inside the loop?

[Yang, 2014/03/28 09:56:58]

No. This is working as intended. The string we are dumping to may be
extended/reallocated as we go. So if we had a new handle scope in each loop, we
would also have to escape the handle in each loop, like at the end of this
function. The way it currently is works fine, we can change it if it turns out
to be a problem at some point.

       Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
       // TODO(rossberg): Should this throw?
       if (!name->IsString()) continue;
       Handle<String> key = Handle<String>::cast(name);
       PropertyDetails details = map->instance_descriptors()->GetDetails(i);
       if (details.IsDontEnum()) continue;
       Handle<Object> property;
       if (details.type() == FIELD && *map == object->map()) {
         property = Handle<Object>(
                        object->RawFastPropertyAt(
                            map->instance_descriptors()->GetFieldIndex(i)),
                        isolate_);
       } else {
-        property = GetProperty(isolate_, object, key);
+        property = Object::GetPropertyOrElement(object, key);
         RETURN_IF_EMPTY_HANDLE_VALUE(isolate_, property, EXCEPTION);
       }
       Result result = SerializeProperty(property, comma, key);
       if (!comma && result == SUCCESS) comma = true;
       if (result >= EXCEPTION) return result;
     }
   } else {
     bool has_exception = false;
     Handle<FixedArray> contents =
         GetKeysInFixedArrayFor(object, LOCAL_ONLY, &has_exception);
     if (has_exception) return EXCEPTION;
 
     for (int i = 0; i < contents->length(); i++) {

[Igor Sheludko, 2014/03/26 18:37:31]

And here?

       Object* key = contents->get(i);
       Handle<String> key_handle;
       Handle<Object> property;
       if (key->IsString()) {
         key_handle = Handle<String>(String::cast(key), isolate_);
-        property = GetProperty(isolate_, object, key_handle);
+        property = Object::GetPropertyOrElement(object, key_handle);
       } else {
         ASSERT(key->IsNumber());
         key_handle = factory_->NumberToString(Handle<Object>(key, isolate_));
         uint32_t index;
         if (key->IsSmi()) {
           property = Object::GetElement(
               isolate_, object, Smi::cast(key)->value());
         } else if (key_handle->AsArrayIndex(&index)) {
           property = Object::GetElement(isolate_, object, index);
         } else {
-          property = GetProperty(isolate_, object, key_handle);
+          property = Object::GetPropertyOrElement(object, key_handle);
         }
       }
       RETURN_IF_EMPTY_HANDLE_VALUE(isolate_, property, EXCEPTION);
       Result result = SerializeProperty(property, comma, key_handle);
       if (!comma && result == SUCCESS) comma = true;
       if (result >= EXCEPTION) return result;
     }
   }
 
   Append('}');
@@ skipping 162 matching lines @@
       SerializeString_<false, uint8_t>(object);
     } else {
       SerializeString_<false, uc16>(object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_