[debugger] remove frame argument for prepare step.

src/debug/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/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 475 matching lines @@
     // Clear all current stepping setup.
     ClearStepping();
 
     if (thread_local_.queued_step_count_ > 0) {
       // Perform queued steps
       int step_count = thread_local_.queued_step_count_;
 
       // Clear queue
       thread_local_.queued_step_count_ = 0;
 
-      PrepareStep(StepNext, step_count, StackFrame::NO_ID);
+      PrepareStep(StepNext, step_count);
     } else {
       // Notify the debug event listeners.
       OnDebugBreak(break_points_hit, false);
     }
   } else if (thread_local_.last_step_action_ != StepNone) {
     // Hold on to last step action as it is cleared by the call to
     // ClearStepping.
     StepAction step_action = thread_local_.last_step_action_;
     int step_count = thread_local_.step_count_;
 
@@ skipping 17 matching lines @@
 
       // Set up for StepOut to reach target frame.
       step_action = StepOut;
       step_count = count;
     }
 
     // Clear all current stepping setup.
     ClearStepping();
 
     // Set up for the remaining steps.
-    PrepareStep(step_action, step_count, StackFrame::NO_ID);
+    PrepareStep(step_action, step_count);
   }
 }
 
 
 // Check the break point objects for whether one or more are actually
 // triggered. This function returns a JSArray with the break point objects
 // which is triggered.
 Handle<Object> Debug::CheckBreakPoints(Handle<Object> break_point_objects) {
   Factory* factory = isolate_->factory();
 
@@ skipping 281 matching lines @@
          !it.frame()->function()->shared()->IsSubjectToDebugging()) {
     it.Advance();
   }
 
   if (it.done()) return;  // No suitable Javascript catch handler.
 
   FloodWithOneShot(Handle<JSFunction>(it.frame()->function()));
 }
 
 
-void Debug::PrepareStep(StepAction step_action,
-                        int step_count,
-                        StackFrame::Id frame_id) {
+void Debug::PrepareStep(StepAction step_action, int step_count) {
   HandleScope scope(isolate_);
 
   DCHECK(in_debug_scope());
 
   // Get the frame where the execution has stopped and skip the debug frame if
   // any. The debug frame will only be present if execution was stopped due to
   // hitting a break point. In other situations (e.g. unhandled exception) the
   // debug frame is not present.
-  StackFrame::Id id = break_frame_id();
-  if (id == StackFrame::NO_ID) {
-    // If there is no JavaScript stack don't do anything.
-    return;
-  }
-  if (frame_id != StackFrame::NO_ID) {
-    id = frame_id;
-  }
-  JavaScriptFrameIterator frames_it(isolate_, id);
+  StackFrame::Id frame_id = break_frame_id();
+  // If there is no JavaScript stack don't do anything.
+  if (frame_id == StackFrame::NO_ID) return;
+
+  JavaScriptFrameIterator frames_it(isolate_, frame_id);
   JavaScriptFrame* frame = frames_it.frame();
 
   feature_tracker()->Track(DebugFeatureTracker::kStepping);
 
   // Remember this step action and count.
   thread_local_.last_step_action_ = step_action;
   STATIC_ASSERT(StepFrame > StepIn);
   thread_local_.step_in_enabled_ = (step_action >= StepIn);
   if (step_action == StepOut) {
     // For step out target frame will be found on the stack so there is no need
@@ skipping 1647 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8