Handlify Object::GetPrototype and (most) callers.

src/accessors.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 25 matching lines @@
 #include "frames-inl.h"
 #include "isolate.h"
 #include "list-inl.h"
 #include "property-details.h"
 
 namespace v8 {
 namespace internal {
 
 
 template <class C>
-static C* FindInstanceOf(Isolate* isolate, Object* obj) {
-  for (Object* cur = obj; !cur->IsNull(); cur = cur->GetPrototype(isolate)) {
-    if (Is<C>(cur)) return C::cast(cur);
+static Handle<C> FindInstanceOf(Isolate* isolate, Handle<Object> obj) {
+  for (Handle<Object> cur = obj;
+      !cur->IsNull();
+      cur = Object::GetPrototype(isolate, cur)) {
+    if (Is<C>(*cur)) return Handle<C>::cast(cur);
   }
-  return NULL;
+  return Handle<C>::null();
 }
 
 
 // Entry point that never should be called.
 MaybeObject* Accessors::IllegalSetter(Isolate* isolate,
                                       JSObject*,
                                       Object*,
                                       void*) {
   UNREACHABLE();
   return NULL;
@@ skipping 89 matching lines @@
 
 //
 // Accessors::ArrayLength
 //
 
 
 MaybeObject* Accessors::ArrayGetLength(Isolate* isolate,
                                        Object* object,
                                        void*) {
   // Traverse the prototype chain until we reach an array.
-  JSArray* holder = FindInstanceOf<JSArray>(isolate, object);
-  return holder == NULL ? Smi::FromInt(0) : holder->length();
+  Handle<JSArray> holder =
+      FindInstanceOf<JSArray>(isolate, handle(object, isolate));
+  return holder.is_null() ? Smi::FromInt(0) : holder->length();
 }
 
 
 // The helper function will 'flatten' Number objects.
 Handle<Object> Accessors::FlattenNumber(Isolate* isolate,
                                         Handle<Object> value) {
   if (value->IsNumber() || !value->IsJSValue()) return value;
   Handle<JSValue> wrapper = Handle<JSValue>::cast(value);
   ASSERT(wrapper->GetIsolate()->context()->native_context()->number_function()->
       has_initial_map());
@@ skipping 382 matching lines @@
                                                      *function,
                                                      *prototype,
                                                      NULL),
                      Object);
 }
 
 
 MaybeObject* Accessors::FunctionGetPrototype(Isolate* isolate,
                                              Object* object,
                                              void*) {
-  JSFunction* function_raw = FindInstanceOf<JSFunction>(isolate, object);
-  if (function_raw == NULL) return isolate->heap()->undefined_value();
-  while (!function_raw->should_have_prototype()) {
-    function_raw = FindInstanceOf<JSFunction>(isolate,
-                                              function_raw->GetPrototype());
+  HandleScope scope(isolate);
+  Handle<JSFunction> function =
+      FindInstanceOf<JSFunction>(isolate, handle(object, isolate));
+  if (function.is_null()) return isolate->heap()->undefined_value();
+  while (!function->should_have_prototype()) {
+    function = FindInstanceOf<JSFunction>(
+        isolate,
+        Object::GetPrototype(isolate, function));
     // There has to be one because we hit the getter.
-    ASSERT(function_raw != NULL);
+    ASSERT(!function.is_null());
   }
 
-  if (!function_raw->has_prototype()) {
-    HandleScope scope(isolate);
-    Handle<JSFunction> function(function_raw);
+  if (!function->has_prototype()) {
     Handle<Object> proto = isolate->factory()->NewFunctionPrototype(function);
     JSFunction::SetPrototype(function, proto);
-    function_raw = *function;
   }
-  return function_raw->prototype();
+  return function->prototype();
 }
 
 
 MaybeObject* Accessors::FunctionSetPrototype(Isolate* isolate,
                                              JSObject* object_raw,
                                              Object* value_raw,
                                              void*) {
-  JSFunction* function_raw = FindInstanceOf<JSFunction>(isolate, object_raw);
-  if (function_raw == NULL) return isolate->heap()->undefined_value();
-
   HandleScope scope(isolate);
-  Handle<JSFunction> function(function_raw, isolate);
   Handle<JSObject> object(object_raw, isolate);
   Handle<Object> value(value_raw, isolate);
+  Handle<JSFunction> function = FindInstanceOf<JSFunction>(isolate, object);
+  if (function.is_null()) return isolate->heap()->undefined_value();
+
   if (!function->should_have_prototype()) {
     // Since we hit this accessor, object will have no prototype property.
     Handle<Object> result;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, result,
         JSObject::SetLocalPropertyIgnoreAttributes(
             object, isolate->factory()->prototype_string(), value, NONE));
     return *result;
   }
 
@@ skipping 26 matching lines @@
 
 
 //
 // Accessors::FunctionLength
 //
 
 
 MaybeObject* Accessors::FunctionGetLength(Isolate* isolate,
                                           Object* object,
                                           void*) {
-  JSFunction* function = FindInstanceOf<JSFunction>(isolate, object);
-  if (function == NULL) return Smi::FromInt(0);
+  HandleScope scope(isolate);
+  Handle<JSFunction> function =
+      FindInstanceOf<JSFunction>(isolate, handle(object, isolate));
+  if (function.is_null()) return Smi::FromInt(0);
   // Check if already compiled.
   if (function->shared()->is_compiled()) {
     return Smi::FromInt(function->shared()->length());
   }
   // If the function isn't compiled yet, the length is not computed correctly
   // yet. Compile it now and return the right length.
-  HandleScope scope(isolate);
-  Handle<JSFunction> function_handle(function);
-  if (Compiler::EnsureCompiled(function_handle, KEEP_EXCEPTION)) {
-    return Smi::FromInt(function_handle->shared()->length());
+  if (Compiler::EnsureCompiled(function, KEEP_EXCEPTION)) {
+    return Smi::FromInt(function->shared()->length());
   }
   return Failure::Exception();
 }
 
 
 const AccessorDescriptor Accessors::FunctionLength = {
   FunctionGetLength,
   ReadOnlySetAccessor,
   0
 };
 
 
 //
 // Accessors::FunctionName
 //
 
 
 MaybeObject* Accessors::FunctionGetName(Isolate* isolate,
                                         Object* object,
                                         void*) {
-  JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
-  return holder == NULL
+  HandleScope scope(isolate);
+  Handle<JSFunction> holder =
+      FindInstanceOf<JSFunction>(isolate, handle(object, isolate));
+  return holder.is_null()
       ? isolate->heap()->undefined_value()
       : holder->shared()->name();
 }
 
 
 const AccessorDescriptor Accessors::FunctionName = {
   FunctionGetName,
   ReadOnlySetAccessor,
   0
 };
@@ skipping 38 matching lines @@
 
   // Return the freshly allocated arguments object.
   return *arguments;
 }
 
 
 MaybeObject* Accessors::FunctionGetArguments(Isolate* isolate,
                                              Object* object,
                                              void*) {
   HandleScope scope(isolate);
-  JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
-  if (holder == NULL) return isolate->heap()->undefined_value();
-  Handle<JSFunction> function(holder, isolate);
+  Handle<JSFunction> function =
+      FindInstanceOf<JSFunction>(isolate, handle(object, isolate));
+  if (function.is_null()) return isolate->heap()->undefined_value();
 
   if (function->shared()->native()) return isolate->heap()->null_value();
   // Find the top invocation of the function by traversing frames.
   List<JSFunction*> functions(2);
   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     frame->GetFunctions(&functions);
     for (int i = functions.length() - 1; i >= 0; i--) {
       // Skip all frames that aren't invocations of the given function.
       if (functions[i] != *function) continue;
@@ skipping 102 matching lines @@
   List<JSFunction*> functions_;
   int index_;
 };
 
 
 MaybeObject* Accessors::FunctionGetCaller(Isolate* isolate,
                                           Object* object,
                                           void*) {
   HandleScope scope(isolate);
   DisallowHeapAllocation no_allocation;
-  JSFunction* holder = FindInstanceOf<JSFunction>(isolate, object);
-  if (holder == NULL) return isolate->heap()->undefined_value();
-  if (holder->shared()->native()) return isolate->heap()->null_value();
-  Handle<JSFunction> function(holder, isolate);
+  Handle<JSFunction> function =
+     FindInstanceOf<JSFunction>(isolate, handle(object, isolate));
+  if (function.is_null()) return isolate->heap()->undefined_value();
+  if (function->shared()->native()) return isolate->heap()->null_value();
 
   FrameFunctionIterator it(isolate, no_allocation);
 
   // Find the function from the frames.
   if (!it.Find(*function)) {
     // No frame corresponding to the given function found. Return null.
     return isolate->heap()->null_value();
   }
 
   // Find previously called non-toplevel function.
@@ skipping 96 matching lines @@
   info->set_data(Smi::FromInt(index));
   Handle<Object> getter = v8::FromCData(isolate, &ModuleGetExport);
   Handle<Object> setter = v8::FromCData(isolate, &ModuleSetExport);
   info->set_getter(*getter);
   if (!(attributes & ReadOnly)) info->set_setter(*setter);
   return info;
 }
 
 
 } }  // namespace v8::internal