Remove DebuggerEvent. Refactor remaining code.

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_tools_api.h"
 
 #include "vm/object.h"
 #include "vm/port.h"
+#include "vm/service_event.h"
 
 namespace dart {
 
 class CodeBreakpoint;
 class Isolate;
 class JSONArray;
 class JSONStream;
 class ObjectPointerVisitor;
 class RemoteObjectCache;
 class BreakpointLocation;
@@ skipping 340 matching lines @@
 
  private:
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
 
-class DebuggerEvent {
- public:
-  enum EventType {
-    kBreakpointReached = 1,
-    kBreakpointResolved = 2,
-    kExceptionThrown = 3,
-    kIsolateCreated = 4,
-    kIsolateShutdown = 5,
-    kIsolateInterrupted = 6,
-  };
-
-  explicit DebuggerEvent(Isolate* isolate, EventType event_type)
-      : isolate_(isolate),
-        type_(event_type),
-        top_frame_(NULL),
-        breakpoint_(NULL),
-        exception_(NULL),
-        async_continuation_(NULL),
-        at_async_jump_(false),
-        timestamp_(-1) {}
-
-  Isolate* isolate() const { return isolate_; }
-
-  EventType type() const { return type_; }
-
-  bool IsPauseEvent() const {
-    return (type_ == kBreakpointReached ||
-            type_ == kIsolateInterrupted ||
-            type_ == kExceptionThrown);
-  }
-
-  ActivationFrame* top_frame() const {
-    ASSERT(IsPauseEvent());
-    return top_frame_;
-  }
-  void set_top_frame(ActivationFrame* frame) {
-    ASSERT(IsPauseEvent());
-    top_frame_ = frame;
-  }
-
-  Breakpoint* breakpoint() const {
-    ASSERT(type_ == kBreakpointReached || type_ == kBreakpointResolved);
-    return breakpoint_;
-  }
-  void set_breakpoint(Breakpoint* bpt) {
-    ASSERT(type_ == kBreakpointReached || type_ == kBreakpointResolved);
-    breakpoint_ = bpt;
-  }
-
-  const Object* exception() const {
-    ASSERT(type_ == kExceptionThrown);
-    return exception_;
-  }
-  void set_exception(const Object* exception) {
-    ASSERT(type_ == kExceptionThrown);
-    exception_ = exception;
-  }
-
-  const Object* async_continuation() const {
-    ASSERT(type_ == kBreakpointReached);
-    return async_continuation_;
-  }
-  void set_async_continuation(const Object* closure) {
-    ASSERT(type_ == kBreakpointReached);
-    async_continuation_ = closure;
-  }
-
-  bool at_async_jump() const {
-    return at_async_jump_;
-  }
-  void set_at_async_jump(bool value) {
-    at_async_jump_ = value;
-  }
-
-  Dart_Port isolate_id() const {
-    return isolate_->main_port();
-  }
-
-  void UpdateTimestamp();
-
-  int64_t timestamp() const {
-    return timestamp_;
-  }
-
- private:
-  Isolate* isolate_;
-  EventType type_;
-  ActivationFrame* top_frame_;
-  Breakpoint* breakpoint_;
-  const Object* exception_;
-  const Object* async_continuation_;
-  bool at_async_jump_;
-  int64_t timestamp_;
-};
-
-
 class Debugger {
  public:
-  typedef void EventHandler(DebuggerEvent* event);
+  typedef void EventHandler(ServiceEvent* event);
 
   Debugger();
   ~Debugger();
 
   void Initialize(Isolate* isolate);
   void NotifyIsolateCreated();
   void Shutdown();
 
   void NotifyCompilation(const Function& func);
   void NotifyDoneLoading();
@@ skipping 37 matching lines @@
   // Put the isolate into single stepping mode when Dart code next runs.
   //
   // This is used by the vm service to allow the user to step while
   // paused at isolate start.
   void EnterSingleStepMode();
 
   // Indicates why the debugger is currently paused.  If the debugger
   // is not paused, this returns NULL.  Note that the debugger can be
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
-  const DebuggerEvent* PauseEvent() const { return pause_event_; }
+  const ServiceEvent* PauseEvent() const { return pause_event_; }
 
   void SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info);
   Dart_ExceptionPauseInfo GetExceptionPauseInfo() const;
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   // Called from Runtime when a breakpoint in Dart code is reached.
   void BreakpointCallback();
 
   // Returns true if there is at least one breakpoint set in func or code.
@@ skipping 34 matching lines @@
 
   // Utility functions.
   static const char* QualifiedFunctionName(const Function& func);
 
   RawObject* GetInstanceField(const Class& cls,
                               const String& field_name,
                               const Instance& object);
   RawObject* GetStaticField(const Class& cls,
                             const String& field_name);
 
-  RawError* SignalBpReached();
-  RawError* DebuggerStepCallback();
-  RawError* SignalIsolateInterrupted();
+  // Pause execution for a breakpoint.  Called from generated code.
+  RawError* PauseBreakpoint();
 
-  void BreakHere(const String& msg);
+  // Pause execution due to stepping.  Called from generated code.
+  RawError* PauseStepping();
 
-  void SignalExceptionThrown(const Instance& exc);
-  void SignalIsolateEvent(DebuggerEvent::EventType type);
+  // Pause execution due to isolate interrupt.
+  RawError* PauseInterrupted();
+
+  // Pause execution due to an uncaught exception.
+  void PauseException(const Instance& exc);
+
+  // Pause execution due to a call to the debugger() function from
+  // Dart.
+  void PauseDeveloper(const String& msg);
 
   RawCode* GetPatchedStubAddress(uword breakpoint_address);
 
   void PrintBreakpointsToJSONArray(JSONArray* jsarr) const;
   void PrintSettingsToJSONObject(JSONObject* jsobj) const;
 
   static bool IsDebuggable(const Function& func);
 
   intptr_t limitBreakpointId() { return next_id_; }
 
  private:
   enum ResumeAction {
     kContinue,
     kStepOver,
     kStepOut,
     kSingleStep
   };
 
-  static bool HasAnyEventHandler();
-  static bool HasDebugEventHandler();
-  void InvokeEventHandler(DebuggerEvent* event);
+  bool NeedsIsolateEvents();
+  bool NeedsDebugEvents();
+  void InvokeEventHandler(ServiceEvent* event);
+
+  void SendBreakpointEvent(ServiceEvent::EventKind kind, Breakpoint* bpt);
+
   bool IsAtAsyncJump(ActivationFrame* top_frame);
   void FindCompiledFunctions(const Script& script,
                              TokenPosition start_pos,
                              TokenPosition end_pos,
                              GrowableObjectArray* function_list);
   RawFunction* FindBestFit(const Script& script, TokenPosition token_pos);
   RawFunction* FindInnermostClosure(const Function& function,
                                     TokenPosition token_pos);
   TokenPosition ResolveBreakpointPos(const Function& func,
                                        TokenPosition requested_token_pos,
@@ skipping 26 matching lines @@
   static ActivationFrame* CollectDartFrame(Isolate* isolate,
                                            uword pc,
                                            StackFrame* frame,
                                            const Code& code,
                                            const Array& deopt_frame,
                                            intptr_t deopt_frame_offset);
   static RawArray* DeoptimizeToArray(Thread* thread,
                                      StackFrame* frame,
                                      const Code& code);
   static DebuggerStackTrace* CollectStackTrace();
-  void SignalBpResolved(Breakpoint *bpt);
   void SignalPausedEvent(ActivationFrame* top_frame,
                          Breakpoint* bpt);
 
   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);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
-  void Pause(DebuggerEvent* event);
+  void Pause(ServiceEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                              bool skip_next_step = false);
 
   Isolate* isolate_;
   Dart_Port isolate_id_;  // A unique ID for the isolate in the debugger.
   bool initialized_;
-  bool creation_message_sent_;  // The creation message has been sent.
 
   // ID number generator.
   intptr_t next_id_;
 
   BreakpointLocation* latent_locations_;
   BreakpointLocation* breakpoint_locations_;
   CodeBreakpoint* code_breakpoints_;
 
   // Tells debugger what to do when resuming execution after a breakpoint.
   ResumeAction resume_action_;
 
   // Do not call back to breakpoint handler if this flag is set.
   // Effectively this means ignoring breakpoints. Set when Dart code may
   // be run as a side effect of getting values of fields.
   bool ignore_breakpoints_;
 
   // Indicates why the debugger is currently paused.  If the debugger
   // is not paused, this is NULL.  Note that the debugger can be
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
-  DebuggerEvent* pause_event_;
+  ServiceEvent* pause_event_;
 
   // An id -> object map.  Valid only while IsPaused().
   RemoteObjectCache* obj_cache_;
 
   // Current stack trace. Valid only while IsPaused().
   DebuggerStackTrace* stack_trace_;
 
   // When stepping through code, only pause the program if the top
   // frame corresponds to this fp value, or if the top frame is
   // lower on the stack.
@@ skipping 15 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_