Return MaybeHandle from Invoke.

src/handles.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 388 matching lines @@
 Handle<Object> GetScriptNameOrSourceURL(Handle<Script> script) {
   Isolate* isolate = script->GetIsolate();
   Handle<String> name_or_source_url_key =
       isolate->factory()->InternalizeOneByteString(
           STATIC_ASCII_VECTOR("nameOrSourceURL"));
   Handle<JSValue> script_wrapper = GetScriptWrapper(script);
   Handle<Object> property =
       Object::GetProperty(script_wrapper, name_or_source_url_key);
   ASSERT(property->IsJSFunction());
   Handle<JSFunction> method = Handle<JSFunction>::cast(property);
-  bool caught_exception;
-  Handle<Object> result = Execution::TryCall(method, script_wrapper, 0,
-                                             NULL, &caught_exception);
-  if (caught_exception) {
-    result = isolate->factory()->undefined_value();
-  }
+  Handle<Object> result;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate, result,
+      Execution::TryCall(method, script_wrapper, 0, NULL),
+      isolate->factory()->undefined_value());
   return result;
 }
 
 
 static bool ContainsOnlyValidKeys(Handle<FixedArray> array) {
   int len = array->length();
   for (int i = 0; i < len; i++) {
     Object* e = array->get(i);
     if (!(e->IsString() || e->IsNumber())) return false;
   }
@@ skipping 13 matching lines @@
       JSFunction::cast(arguments_boilerplate->map()->constructor()),
       isolate);
 
   // Only collect keys if access is permitted.
   for (Handle<Object> p = object;
        *p != isolate->heap()->null_value();
        p = Handle<Object>(p->GetPrototype(isolate), isolate)) {
     if (p->IsJSProxy()) {
       Handle<JSProxy> proxy(JSProxy::cast(*p), isolate);
       Handle<Object> args[] = { proxy };
-      bool has_pending_exception;
-      Handle<Object> names = Execution::Call(isolate,
-                                             isolate->proxy_enumerate(),
-                                             object,
-                                             ARRAY_SIZE(args),
-                                             args,
-                                             &has_pending_exception);
-      if (has_pending_exception) return MaybeHandle<FixedArray>();
+      Handle<Object> names;
+      ASSIGN_RETURN_ON_EXCEPTION(
+          isolate, names,
+          Execution::Call(isolate,
+                          isolate->proxy_enumerate(),
+                          object,
+                          ARRAY_SIZE(args),
+                          args),
+          FixedArray);
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, content,
-          FixedArray::AddKeysFromJSArray(content, Handle<JSArray>::cast(names)),
+          FixedArray::AddKeysFromJSArray(
+              content, Handle<JSArray>::cast(names)),
           FixedArray);
       break;
     }
 
     Handle<JSObject> current(JSObject::cast(*p), isolate);
 
     // Check access rights if required.
     if (current->IsAccessCheckNeeded() &&
         !isolate->MayNamedAccessWrapper(current,
                                         isolate->factory()->undefined_value(),
@@ skipping 60 matching lines @@
             isolate, content,
             FixedArray::AddKeysFromJSArray(
                 content, v8::Utils::OpenHandle(*result)),
             FixedArray);
       }
       ASSERT(ContainsOnlyValidKeys(content));
     }
 
     // If we only want local properties we bail out after the first
     // iteration.
-    if (type == LOCAL_ONLY)
-      break;
+    if (type == LOCAL_ONLY) break;
   }
   return content;
 }
 
 
-MaybeHandle<JSArray> GetKeysFor(Handle<JSReceiver> object) {
-  Isolate* isolate = object->GetIsolate();
-  isolate->counters()->for_in()->Increment();
-  Handle<FixedArray> elements;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate, elements,
-      GetKeysInFixedArrayFor(object, INCLUDE_PROTOS),
-      JSArray);
-  return isolate->factory()->NewJSArrayWithElements(elements);
-}
-
-
 Handle<FixedArray> ReduceFixedArrayTo(Handle<FixedArray> array, int length) {
   ASSERT(array->length() >= length);
   if (array->length() == length) return array;
 
   Handle<FixedArray> new_array =
       array->GetIsolate()->factory()->NewFixedArray(length);
   for (int i = 0; i < length; ++i) new_array->set(i, array->get(i));
   return new_array;
 }
 
@@ skipping 146 matching lines @@
                                    Handle<Code> code) {
   heap->EnsureWeakObjectToCodeTable();
   Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(*object));
   dep = DependentCode::Insert(dep, DependentCode::kWeaklyEmbeddedGroup, code);
   CALL_HEAP_FUNCTION_VOID(heap->isolate(),
                           heap->AddWeakObjectToCodeDependency(*object, *dep));
 }
 
 
 } }  // namespace v8::internal