Allow stepping into Promise handlers.

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 1181 matching lines @@
 
   // Remove all debug info.
   while (debug_info_list_ != NULL) {
     RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());
   }
 }
 
 
 void Debug::FloodWithOneShot(Handle<JSFunction> function,
                              BreakLocatorType type) {
+  // Do not ever break in native functions.
+  if (function->IsFromNativeScript()) return;

[arv (Not doing code reviews), 2014/11/18 18:51:08]

Maybe this should have been a DCHECK instead. I think all the callers already
try to handle this.

[aandrey, 2014/11/19 11:41:27]

Nope, only two places out of 7-8 in this file. One check I removed at line 1255,
also should remove at line 1229 (which is also not correct before calling
FloodWithOneShotGeneric)

+
   PrepareForBreakPoints();
 
   // Make sure the function is compiled and has set up the debug info.
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if we failed to retrieve the debug info.
     return;
   }
 
   // Flood the function with break points.
@@ skipping 30 matching lines @@
   FloodWithOneShotGeneric(function_proto);
 }
 
 
 void Debug::FloodWithOneShotGeneric(Handle<JSFunction> function,
                                     Handle<Object> holder) {
   if (function->shared()->bound()) {
     FloodBoundFunctionWithOneShot(function);
   } else if (function->shared()->is_default_constructor()) {
     FloodDefaultConstructorWithOneShot(function);
-  } else if (!function->IsFromNativeScript()) {
+  } else {
     Isolate* isolate = function->GetIsolate();
     // Don't allow step into functions in the native context.
     if (function->shared()->code() ==
             isolate->builtins()->builtin(Builtins::kFunctionApply) ||
         function->shared()->code() ==
             isolate->builtins()->builtin(Builtins::kFunctionCall)) {
       // Handle function.apply and function.call separately to flood the
       // function to be called and not the code for Builtins::FunctionApply or
       // Builtins::FunctionCall. The receiver of call/apply is the target
       // function.
@@ skipping 2173 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal