Trigger debug event on not yet caught exception in promises.

src/runtime.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 5631 matching lines @@
   // When leaving the callback, step out has been activated, but not performed
   // if we do not leave the builtin.  To be able to step into the callback
   // again, we need to clear the step out at this point.
   debug->ClearStepOut();
   debug->FloodWithOneShot(callback);
 #endif  // ENABLE_DEBUGGER_SUPPORT
   return isolate->heap()->undefined_value();
 }
 
 
+// Notify the debugger if an expcetion in a promise is not caught (yet).
+RUNTIME_FUNCTION(Runtime_DebugPendingExceptionInPromise) {
+  SealHandleScope shs(isolate);
+#ifdef ENABLE_DEBUGGER_SUPPORT
+  ASSERT(args.length() == 2);
+  HandleScope scope(isolate);

[rossberg, 2014/04/24 07:27:36]

Why have both a SHS and a HS in the same function?

[rossberg, 2014/04/24 08:08:38]

Seems like you missed this one.

+  CONVERT_ARG_HANDLE_CHECKED(Object, exception, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, deferred_promise, 1);

[rossberg, 2014/04/24 07:27:36]

One more.

[Yang, 2014/04/24 10:42:04]

Done.

+  isolate->debugger()->OnException(exception, false, deferred_promise);

[yurys, 2014/04/24 07:48:43]

It might make sense to report the exception as uncaught=true here in case there
is no catch handler on the promise yet.

[Yang, 2014/04/24 07:59:59]

Done.

Alternatively, we could always fire this runtime function, and set uncaught
depending on whether we already have a catch handler. Devtools would then filter
out caught ones. That would give you guys more flexibility (not sure if
necessary).

[yurys, 2014/04/24 08:49:50]

I believe this is not necessary. We have three modes in DevTools:
1) don't pause on exception
2) pause on uncaught exceptions only (controlled by
Debug.setBreakOnUncaughtException();)
3) pause on all exceptions (controlled by  Debug.setBreakOnException();)
All of them are handled in v8 at the moment and I believe the promises should
follow that logic too.

+#endif  // ENABLE_DEBUGGER_SUPPORT
+  return isolate->heap()->undefined_value();
+}
+
+
 // Set a local property, even if it is READ_ONLY.  If the property does not
 // exist, it will be added with attributes NONE.
 RUNTIME_FUNCTION(Runtime_IgnoreAttributesAndSetProperty) {
   HandleScope scope(isolate);
   RUNTIME_ASSERT(args.length() == 3 || args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
   CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
   // Compute attributes.
   PropertyAttributes attributes = NONE;
@@ skipping 9455 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal