Remove assertion from callers of TryCall.

src/debug.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 1109 matching lines @@
   Handle<JSFunction> check_break_point =
     Handle<JSFunction>::cast(Object::GetProperty(
         debug_global, is_break_point_triggered_string).ToHandleChecked());
 
   // Get the break id as an object.
   Handle<Object> break_id = factory->NewNumberFromInt(Debug::break_id());
 
   // Call HandleBreakPointx.
   Handle<Object> argv[] = { break_id, break_point_object };
   Handle<Object> result;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, result,
-      Execution::TryCall(check_break_point,
-                         isolate_->js_builtins_object(),
-                         ARRAY_SIZE(argv),
-                         argv),
-      false);
+  if (!Execution::TryCall(check_break_point,
+                          isolate_->js_builtins_object(),
+                          ARRAY_SIZE(argv),
+                          argv).ToHandle(&result)) {
+    return false;
+  }
 
   // Return whether the break point is triggered.
   return result->IsTrue();
 }
 
 
 // Check whether the function has debug information.
 bool Debug::HasDebugInfo(Handle<SharedFunctionInfo> shared) {
   return !shared->debug_info()->IsUndefined();
 }
@@ skipping 1466 matching lines @@
   // Create the execution state object.
   Handle<Object> break_id = isolate_->factory()->NewNumberFromInt(
       isolate_->debug()->break_id());
   Handle<Object> argv[] = { break_id };
   return MakeJSObject(CStrVector("MakeExecutionState"), ARRAY_SIZE(argv), argv);
 }
 
 
 MaybeHandle<Object> Debugger::MakeBreakEvent(Handle<Object> break_points_hit) {
   Handle<Object> exec_state;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, exec_state, MakeExecutionState(), Object);
+  if (!MakeExecutionState().ToHandle(&exec_state)) return MaybeHandle<Object>();
   // Create the new break event object.
   Handle<Object> argv[] = { exec_state, break_points_hit };
   return MakeJSObject(CStrVector("MakeBreakEvent"), ARRAY_SIZE(argv), argv);
 }
 
 
 MaybeHandle<Object> Debugger::MakeExceptionEvent(Handle<Object> exception,
                                                  bool uncaught) {
   Handle<Object> exec_state;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, exec_state, MakeExecutionState(), Object);
+  if (!MakeExecutionState().ToHandle(&exec_state)) return MaybeHandle<Object>();
   // Create the new exception event object.
   Handle<Object> argv[] = { exec_state,
                             exception,
                             isolate_->factory()->ToBoolean(uncaught) };
   return MakeJSObject(CStrVector("MakeExceptionEvent"), ARRAY_SIZE(argv), argv);
 }
 
 
 MaybeHandle<Object> Debugger::MakeCompileEvent(Handle<Script> script,
                                                bool before) {
-  Factory* factory = isolate_->factory();
+  Handle<Object> exec_state;
+  if (!MakeExecutionState().ToHandle(&exec_state)) return MaybeHandle<Object>();
   // Create the compile event object.
-  Handle<Object> exec_state;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, exec_state, MakeExecutionState(), Object);
   Handle<Object> script_wrapper = GetScriptWrapper(script);
   Handle<Object> argv[] = { exec_state,
                             script_wrapper,
-                            factory->ToBoolean(before) };
+                            isolate_->factory()->ToBoolean(before) };
   return MakeJSObject(CStrVector("MakeCompileEvent"), ARRAY_SIZE(argv), argv);
 }
 
 
 MaybeHandle<Object> Debugger::MakeScriptCollectedEvent(int id) {
+  Handle<Object> exec_state;
+  if (!MakeExecutionState().ToHandle(&exec_state)) return MaybeHandle<Object>();
   // Create the script collected event object.
-  Handle<Object> exec_state;
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, exec_state, MakeExecutionState(), Object);
   Handle<Object> id_object = Handle<Smi>(Smi::FromInt(id), isolate_);
   Handle<Object> argv[] = { exec_state, id_object };
 
   return MakeJSObject(
       CStrVector("MakeScriptCollectedEvent"), ARRAY_SIZE(argv), argv);
 }
 
 
 void Debugger::OnException(Handle<Object> exception, bool uncaught) {
   HandleScope scope(isolate_);
@@ skipping 15 matching lines @@
 
   // Enter the debugger.
   EnterDebugger debugger(isolate_);
   if (debugger.FailedToEnter()) return;
 
   // Clear all current stepping setup.
   debug->ClearStepping();
   // Create the event data object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, event_data, MakeExceptionEvent(exception, uncaught),
-      /* void */ ;);
+  if (!MakeExceptionEvent(exception, uncaught).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
 void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
                             bool auto_continue) {
   HandleScope scope(isolate_);
 
   // Debugger has already been entered by caller.
   ASSERT(isolate_->context() == *isolate_->debug()->debug_context());
 
   // Bail out if there is no listener for this event
   if (!Debugger::EventActive(v8::Break)) return;
 
   // Debugger must be entered in advance.
   ASSERT(isolate_->context() == *isolate_->debug()->debug_context());
 
   // Create the event data object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, event_data, MakeBreakEvent(break_points_hit), /* void */ ;);
+  if (!MakeBreakEvent(break_points_hit).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::Break,
                     Handle<JSObject>::cast(event_data),
                     auto_continue);
 }
 
 
 void Debugger::OnBeforeCompile(Handle<Script> script) {
   HandleScope scope(isolate_);
 
   // Bail out based on state or if there is no listener for this event
   if (isolate_->debug()->InDebugger()) return;
   if (compiling_natives()) return;
   if (!EventActive(v8::BeforeCompile)) return;
 
   // Enter the debugger.
   EnterDebugger debugger(isolate_);
   if (debugger.FailedToEnter()) return;
 
   // Create the event data object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, event_data, MakeCompileEvent(script, true), /* void */ ;);
+  if (!MakeCompileEvent(script, true).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::BeforeCompile,
                     Handle<JSObject>::cast(event_data),
                     true);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script,
@@ skipping 45 matching lines @@
                          argv).is_null()) {
     return;
   }
   // Bail out based on state or if there is no listener for this event
   if (in_debugger && (after_compile_flags & SEND_WHEN_DEBUGGING) == 0) return;
   if (!Debugger::EventActive(v8::AfterCompile)) return;
 
   // Create the compile state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, event_data, MakeCompileEvent(script, false), /* void */ ;);
+  if (!MakeCompileEvent(script, false).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::AfterCompile, Handle<JSObject>::cast(event_data), true);
 }
 
 
 void Debugger::OnScriptCollected(int id) {
   HandleScope scope(isolate_);
 
   // No more to do if not debugging.
   if (isolate_->debug()->InDebugger()) return;
   if (!IsDebuggerActive()) return;
   if (!Debugger::EventActive(v8::ScriptCollected)) return;
 
   // Enter the debugger.
   EnterDebugger debugger(isolate_);
   if (debugger.FailedToEnter()) return;
 
   // Create the script collected state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, event_data, MakeScriptCollectedEvent(id), /* void */ ;);
+  if (!MakeScriptCollectedEvent(id).ToHandle(&event_data)) return;
 
   // Process debug event.
   ProcessDebugEvent(v8::ScriptCollected,
                     Handle<JSObject>::cast(event_data),
                     true);
 }
 
 
 void Debugger::ProcessDebugEvent(v8::DebugEvent event,
                                  Handle<JSObject> event_data,
                                  bool auto_continue) {
   HandleScope scope(isolate_);
 
   // Clear any pending debug break if this is a real break.
   if (!auto_continue) {
     isolate_->debug()->clear_interrupt_pending(DEBUGBREAK);
   }
 
   // Create the execution state.
   Handle<Object> exec_state;
   // Bail out and don't call debugger if exception.
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, exec_state, MakeExecutionState(), /* void */ ;);
+  if (!MakeExecutionState().ToHandle(&exec_state)) return;
+
   // First notify the message handler if any.
   if (message_handler_ != NULL) {
     NotifyMessageHandler(event,
                          Handle<JSObject>::cast(exec_state),
                          event_data,
                          auto_continue);
   }
   // Notify registered debug event listener. This can be either a C or
   // a JavaScript function. Don't call event listener for v8::Break
   // here, if it's only a debug command -- they will be processed later.
@@ skipping 420 matching lines @@
   Debugger::never_unload_debugger_ = true;
 
   // Enter the debugger.
   EnterDebugger debugger(isolate_);
   if (debugger.FailedToEnter()) {
     return isolate_->factory()->undefined_value();
   }
 
   // Create the execution state.
   Handle<Object> exec_state;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, exec_state,
-      MakeExecutionState(),
-      isolate_->factory()->undefined_value());
+  if (!MakeExecutionState().ToHandle(&exec_state)) {
+    return isolate_->factory()->undefined_value();
+  }
 
   Handle<Object> argv[] = { exec_state, data };
   return Execution::Call(
       isolate_,
       fun,
       Handle<Object>(isolate_->debug()->debug_context_->global_proxy(),
                      isolate_),
       ARRAY_SIZE(argv),
       argv);
 }
@@ skipping 429 matching lines @@
     {
       Locker locker(reinterpret_cast<v8::Isolate*>(isolate_));
       isolate_->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal