Fix debugger stack traces

runtime/vm/debugger.h

 // 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.
 
 #ifndef VM_DEBUGGER_H_
 #define VM_DEBUGGER_H_
 
 #include "include/dart_debugger_api.h"
 
 #include "vm/object.h"
@@ skipping 126 matching lines @@
   }
 
   RawString* QualifiedFunctionName();
   RawString* SourceUrl();
   RawScript* SourceScript();
   RawLibrary* Library();
   intptr_t TokenPos();
   intptr_t LineNumber();
   void SetContext(const Context& ctx) { ctx_ = ctx.raw(); }
 
+  // Returns true if this frame is for a function that is visible
+  // to the user and can be debugged.
+  bool IsDebuggable() const;
+
   // The context level of a frame is the context level at the
   // PC/token index of the frame. It determines the depth of the context
   // chain that belongs to the function of this activation frame.
   intptr_t ContextLevel();
 
   const char* ToCString();
 
   intptr_t NumLocalVariables();
 
   void VariableAt(intptr_t i,
@@ skipping 37 matching lines @@
   friend class Debugger;
   friend class DebuggerStackTrace;
   DISALLOW_COPY_AND_ASSIGN(ActivationFrame);
 };
 
 
 // Array of function activations on the call stack.
 class DebuggerStackTrace : public ZoneAllocated {
  public:
   explicit DebuggerStackTrace(int capacity)
-      : trace_(capacity) { }
+      : trace_(capacity),
+        user_trace_(capacity) { }
 
-  intptr_t Length() const { return trace_.length(); }
+  intptr_t Length() const { return user_trace_.length(); }
 
-  ActivationFrame* ActivationFrameAt(int i) const {
-    ASSERT(i < trace_.length());
+  ActivationFrame* FrameAt(int i) const {
+    return user_trace_[i];
+  }
+
+  ActivationFrame* GetHandlerFrame(const Instance& exc_obj) const;
+
+ private:
+  intptr_t UnfilteredLength() const { return trace_.length(); }
+
+  ActivationFrame* UnfilteredFrameAt(int i) const {
     return trace_[i];
   }
-  ActivationFrame* GetHandlerFrame(const Instance& exc_obj) const;
- private:
+
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
+  ZoneGrowableArray<ActivationFrame*> user_trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
 
 typedef void BreakpointHandler(Dart_Port isolate_id,
                                SourceBreakpoint* bpt,
                                DebuggerStackTrace* stack);
 
@@ skipping 82 matching lines @@
                             const String& field_name);
 
   void SignalBpReached();
   void SingleStepCallback();
 
   void SignalExceptionThrown(const Instance& exc);
   static void SignalIsolateEvent(EventType type);
 
   uword GetPatchedStubAddress(uword breakpoint_address);
 
+  static bool IsDebuggable(const Function& func);
+
  private:
   enum ResumeAction {
     kContinue,
     kStepOver,
     kStepOut,
     kSingleStep
   };
 
   intptr_t ResolveBreakpointPos(const Function& func,
                                 intptr_t first_token_pos,
@@ skipping 15 matching lines @@
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
   void SyncBreakpoint(SourceBreakpoint* bpt);
 
   ActivationFrame* TopDartFrame() const;
   static DebuggerStackTrace* CollectStackTrace();
   void SignalBpResolved(SourceBreakpoint *bpt);
   void SignalPausedEvent(ActivationFrame* top_frame);
 
-  static bool IsDebuggable(const Function& func);
-
   intptr_t nextId() { return next_id_++; }
 
   bool ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                               const Instance& exc);
 
   void CollectLibraryFields(const GrowableObjectArray& field_list,
                             const Library& lib,
                             const String& prefix,
                             bool include_private_fields);
 
@@ skipping 30 matching lines @@
 
   friend class Isolate;
   friend class SourceBreakpoint;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_