Filter frames from debugger stack based on visibility rather than "debuggability" (steppability).

runtime/vm/debugger.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 "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 396 matching lines @@
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
   for (intptr_t frame_index = 0;
-       frame_index < UnfilteredLength();
+       frame_index < Length();
        frame_index++) {
-    ActivationFrame* frame = UnfilteredFrameAt(frame_index);
+    ActivationFrame* frame = FrameAt(frame_index);
     intptr_t try_index = frame->TryIndex();
     if (try_index < 0) continue;
     handlers = frame->code().exception_handlers();
     ASSERT(!handlers.IsNull());
     intptr_t num_handlers_checked = 0;
     while (try_index >= 0) {
       // Detect circles in the exception handler data.
       num_handlers_checked++;
       ASSERT(num_handlers_checked <= handlers.Length());
       handled_types = handlers.GetHandledTypes(try_index);
@@ skipping 225 matching lines @@
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, func_name, url.ToCString(), line);
   len++;  // String terminator.
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, func_name, url.ToCString(), line);
   return chars;
 }
 
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
-  trace_.Add(frame);
-  if (frame->IsDebuggable()) {
-    user_trace_.Add(frame);
+  if (frame->function().is_visible()) {
+    trace_.Add(frame);
   }
 }
 
 
 static bool IsSafePoint(PcDescriptors::Kind kind) {
   return ((kind == PcDescriptors::kIcCall) ||
           (kind == PcDescriptors::kOptStaticCall) ||
           (kind == PcDescriptors::kUnoptStaticCall) ||
           (kind == PcDescriptors::kClosureCall) ||
           (kind == PcDescriptors::kReturn) ||
@@ skipping 1203 matching lines @@
 
 
 void Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || in_event_notification_) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
-  ASSERT(stack_trace->UnfilteredLength() > 0);
-  ActivationFrame* top_frame = stack_trace->UnfilteredFrameAt(0);
+  ASSERT(stack_trace->Length() > 0);
+  ActivationFrame* top_frame = stack_trace->FrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(bpt != NULL);
 
   bool report_bp = true;
   if (bpt->IsInternal() && !IsDebuggable(top_frame->function())) {
     report_bp = false;
   }
   if (FLAG_verbose_debug) {
     OS::Print(">>> %s %s breakpoint at %s:%" Pd " "
@@ skipping 259 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart