Dart_SetReturnValue now accepts and propagates error handles.

runtime/vm/native_entry.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/native_entry.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap.h"
 #include "vm/code_patcher.h"
@@ skipping 73 matching lines @@
 uword NativeEntry::NativeCallWrapperEntry() {
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
 #if defined(USING_SIMULATOR)
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
 #endif
   return entry;
 }
 
 
+bool NativeEntry::ReturnValueIsError(NativeArguments* arguments) {
+  RawObject* retval = arguments->ReturnValue();
+  return (retval->IsHeapObject() &&
+          RawObject::IsErrorClassId(retval->GetClassId()));
+}
+
+
+void NativeEntry::PropagateErrors(NativeArguments* arguments) {
+  Thread* thread = arguments->thread();
+  thread->UnwindScopes(thread->top_exit_frame_info());
+
+  // The thread->zone() is different here than before we unwound.
+  const Object& error =
+      Object::Handle(thread->zone(), arguments->ReturnValue());
+  Exceptions::PropagateError(Error::Cast(error));
+  UNREACHABLE();
+}
+
+
 void NativeEntry::NativeCallWrapper(Dart_NativeArguments args,
                                     Dart_NativeFunction func) {
   CHECK_STACK_ALIGNMENT;
   VERIFY_ON_TRANSITION;
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   /* Tell MemorySanitizer 'arguments' is initialized by generated code. */
   MSAN_UNPOISON(arguments, sizeof(*arguments));
   Thread* thread = arguments->thread();
   if (!arguments->IsNativeAutoSetupScope()) {
     TransitionGeneratedToNative transition(thread);
     func(args);
+    if (ReturnValueIsError(arguments)) {
+      PropagateErrors(arguments);
+    }
   } else {
     Isolate* isolate = thread->isolate();
     ApiState* state = isolate->api_state();
     ASSERT(state != NULL);
     ApiLocalScope* current_top_scope = thread->api_top_scope();
     ApiLocalScope* scope = thread->api_reusable_scope();
     TRACE_NATIVE_CALL("0x%" Px "", reinterpret_cast<uintptr_t>(func));
     TransitionGeneratedToNative transition(thread);
     if (scope == NULL) {
       scope = new ApiLocalScope(current_top_scope,
                                 thread->top_exit_frame_info());
       ASSERT(scope != NULL);
     } else {
       scope->Reinit(thread,
                     current_top_scope,
                     thread->top_exit_frame_info());
       thread->set_api_reusable_scope(NULL);
     }
     thread->set_api_top_scope(scope);  // New scope is now the top scope.
 
     func(args);
+    if (ReturnValueIsError(arguments)) {
+      PropagateErrors(arguments);
+    }
 
     ASSERT(current_top_scope == scope->previous());
     thread->set_api_top_scope(current_top_scope);  // Reset top scope to prev.
     if (thread->api_reusable_scope() == NULL) {
       scope->Reset(thread);  // Reset the old scope which we just exited.
       thread->set_api_reusable_scope(scope);
     } else {
       ASSERT(thread->api_reusable_scope() != scope);
       delete scope;
     }
@@ skipping 115 matching lines @@
   if (call_through_wrapper) {
     NativeEntry::NativeCallWrapper(
         args, reinterpret_cast<Dart_NativeFunction>(target_function));
   } else {
     target_function(arguments);
   }
 }
 
 
 }  // namespace dart