Make exception thrown via v8 public API propagate to v8::TryCatch as JS thrown exceptions do.

src/api.cc

 // Copyright 2010 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 1390 matching lines @@
 v8::Handle<v8::Value> v8::TryCatch::ReThrow() {
   if (!HasCaught()) return v8::Local<v8::Value>();
   rethrow_ = true;
   return v8::Undefined();
 }
 
 
 v8::Local<Value> v8::TryCatch::Exception() const {
   if (HasCaught()) {
     // Check for out of memory exception.
     i::Object* exception = reinterpret_cast<i::Object*>(exception_);

[Vitaly Repeshko, 2011/01/28 14:03:33]

Hmm, how is this supposed to work with a raw pointer? Can't a GC happen before
we read it?

[antonm, 2011/01/28 14:43:18]

Take a look at Top::Iterate---it turns exception_ in all trycatches roots if I
am reading the code correctly.

Or are you asking something else?

     return v8::Utils::ToLocal(i::Handle<i::Object>(exception));
   } else {
     return v8::Local<Value>();
   }
 }
 
 
 v8::Local<Value> v8::TryCatch::StackTrace() const {
   if (HasCaught()) {
     i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
@@ skipping 948 matching lines @@
   i::Handle<i::Object> result = i::GetPrototype(self);
   return Utils::ToLocal(result);
 }
 
 
 bool v8::Object::SetPrototype(Handle<Value> value) {
   ON_BAILOUT("v8::Object::SetPrototype()", return false);
   ENTER_V8;
   i::Handle<i::JSObject> self = Utils::OpenHandle(this);
   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
+  // We do not allow exceptions thrown while setting the prototype
+  // propagate outside.
+  TryCatch try_catch;
   EXCEPTION_PREAMBLE();
   i::Handle<i::Object> result = i::SetPrototype(self, value_obj);
   has_pending_exception = result.is_null();
   EXCEPTION_BAILOUT_CHECK(false);
   return true;
 }
 
 
 Local<Object> v8::Object::FindInstanceInPrototypeChain(
     v8::Handle<FunctionTemplate> tmpl) {
@@ skipping 166 matching lines @@
   return Utils::OpenHandle(this)->HasNamedInterceptor();
 }
 
 
 bool v8::Object::HasIndexedLookupInterceptor() {
   ON_BAILOUT("v8::Object::HasIndexedLookupInterceptor()", return false);
   return Utils::OpenHandle(this)->HasIndexedInterceptor();
 }
 
 
+static Local<Value> GetPropertyByLookup(i::Handle<i::JSObject> receiver,
+                                        i::Handle<i::String> name,
+                                        i::LookupResult* lookup) {
+  if (!lookup->IsProperty()) {
+    // No real property was found.
+    return Local<Value>();
+  }
+
+  EXCEPTION_PREAMBLE();
+
+  PropertyAttributes attributes;
+  i::MaybeObject* value =
+      receiver->GetProperty(*receiver, lookup, *name, &attributes);
+
+  // If the property being looked up is a callback, it can throw
+  // an exception.
+  has_pending_exception = value->IsFailure();

[Mads Ager (chromium), 2011/01/28 11:39:18]

Should you test for value->IsException instead and assert that it cannot be
OutOfMemory or RetryAfterGC?

[antonm, 2011/01/28 13:37:25]

I can, but not sure if it's a good idea.  Plus technically we can probably have
OOM here if callback is JS thing which exhausts the memory.  I hope that
EXCEPTION_ macros should cope with any kind of failure.

Am I missing something?

+  EXCEPTION_BAILOUT_CHECK(Local<Value>());
+
+  i::Handle<i::Object> result(value->ToObjectUnchecked());
+  return Utils::ToLocal(result);
+}
+
+
 Local<Value> v8::Object::GetRealNamedPropertyInPrototypeChain(
       Handle<String> key) {
   ON_BAILOUT("v8::Object::GetRealNamedPropertyInPrototypeChain()",
              return Local<Value>());
   ENTER_V8;
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::LookupResult lookup;
   self_obj->LookupRealNamedPropertyInPrototypes(*key_obj, &lookup);
-  if (lookup.IsProperty()) {
-    PropertyAttributes attributes;
-    i::Object* property =
-        self_obj->GetProperty(*self_obj,
-                              &lookup,
-                              *key_obj,
-                              &attributes)->ToObjectUnchecked();
-    i::Handle<i::Object> result(property);
-    return Utils::ToLocal(result);
-  }
-  return Local<Value>();  // No real property was found in prototype chain.
+  return GetPropertyByLookup(self_obj, key_obj, &lookup);
 }
 
 
 Local<Value> v8::Object::GetRealNamedProperty(Handle<String> key) {
   ON_BAILOUT("v8::Object::GetRealNamedProperty()", return Local<Value>());
   ENTER_V8;
   i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this);
   i::Handle<i::String> key_obj = Utils::OpenHandle(*key);
   i::LookupResult lookup;
   self_obj->LookupRealNamedProperty(*key_obj, &lookup);
-  if (lookup.IsProperty()) {
-    PropertyAttributes attributes;
-    i::Object* property =
-        self_obj->GetProperty(*self_obj,
-                              &lookup,
-                              *key_obj,
-                              &attributes)->ToObjectUnchecked();
-    i::Handle<i::Object> result(property);
-    return Utils::ToLocal(result);
-  }
-  return Local<Value>();  // No real property was found in prototype chain.
+  return GetPropertyByLookup(self_obj, key_obj, &lookup);
 }
 
 
 // Turns on access checks by copying the map and setting the check flag.
 // Because the object gets a new map, existing inline cache caching
 // the old map of this object will fail.
 void v8::Object::TurnOnAccessCheck() {
   ON_BAILOUT("v8::Object::TurnOnAccessCheck()", return);
   ENTER_V8;
   HandleScope scope;
@@ skipping 2539 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal