- Remove a couple static_cast and make them safe, by checking

vm/dart_api_impl.cc

 // Copyright (c) 2012, 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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 439 matching lines @@
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, exception, Instance);
   }
   const Instance& stacktrace = Instance::Handle(isolate);
   return Api::NewHandle(isolate, UnhandledException::New(obj, stacktrace));
 }
 
 
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
-  if (!obj.IsError()) {
-    return Api::NewError(
-        "%s expects argument 'handle' to be an error handle.  "
-        "Did you forget to check Dart_IsError first?",
-        CURRENT_FUNC);
+  {
+    const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
+    if (!obj.IsError()) {
+      return Api::NewError(
+          "%s expects argument 'handle' to be an error handle.  "
+          "Did you forget to check Dart_IsError first?",
+          CURRENT_FUNC);
+    }
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // propagate an error here.
     return Api::NewError("No Dart frames on stack, cannot propagate error.");
   }
 
   // Unwind all the API scopes till the exit frame before propagating.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Error* error;
   {
     // We need to preserve the error object across the destruction of zones
     // when the ApiScopes are unwound.  By using NoGCScope, we can ensure
     // that GC won't touch the raw error object before creating a valid
     // handle for it in the surviving zone.
     NoGCScope no_gc;
-    RawError* raw_error = static_cast<RawError*>(Api::UnwrapHandle(handle));
+    RawError* raw_error = Api::UnwrapErrorHandle(isolate, handle).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     error = &Error::Handle(isolate, raw_error);
   }
   Exceptions::PropagateError(*error);
   UNREACHABLE();
   return Api::NewError("Cannot reach here.  Internal error.");
 }
 
 
 DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
@@ skipping 3425 matching lines @@
     return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   {
     NoGCScope no_gc;
     RawInstance* raw_exception =
-        static_cast<RawInstance*>(Api::UnwrapHandle(exception));
+        Api::UnwrapInstanceHandle(isolate, exception).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
   }
   Exceptions::Throw(*saved_exception);
   return Api::NewError("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
@@ skipping 16 matching lines @@
   }
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   const Instance* saved_stacktrace;
   {
     NoGCScope no_gc;
     RawInstance* raw_exception =
-        static_cast<RawInstance*>(Api::UnwrapHandle(exception));
+        Api::UnwrapInstanceHandle(isolate, exception).raw();
     RawInstance* raw_stacktrace =
-        static_cast<RawInstance*>(Api::UnwrapHandle(stacktrace));
+        Api::UnwrapInstanceHandle(isolate, stacktrace).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
     saved_stacktrace = &Instance::Handle(raw_stacktrace);
   }
   Exceptions::ReThrow(*saved_exception, *saved_stacktrace);
   return Api::NewError("Exception was not re thrown, internal error");
 }
 
 
 // --- Native functions ---
@@ skipping 528 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart