clang-format runtime/vm

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 RUNTIME_VM_DEBUGGER_H_
 #define RUNTIME_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;
 class StackFrame;
 
 // A user-defined breakpoint, which either fires once, for a particular closure,
 // or always. The API's notion of a breakpoint corresponds to this object.
 class Breakpoint {
  public:
   Breakpoint(intptr_t id, BreakpointLocation* bpt_location)
-    : id_(id),
-      kind_(Breakpoint::kNone),
-      next_(NULL),
-      closure_(Instance::null()),
-      bpt_location_(bpt_location),
-      is_synthetic_async_(false) {}
+      : id_(id),
+        kind_(Breakpoint::kNone),
+        next_(NULL),
+        closure_(Instance::null()),
+        bpt_location_(bpt_location),
+        is_synthetic_async_(false) {}
 
   intptr_t id() const { return id_; }
   Breakpoint* next() const { return next_; }
   void set_next(Breakpoint* n) { next_ = n; }
 
   BreakpointLocation* bpt_location() const { return bpt_location_; }
   void set_bpt_location(BreakpointLocation* new_bpt_location);
 
   bool IsRepeated() const { return kind_ == kRepeated; }
   bool IsSingleShot() const { return kind_ == kSingleShot; }
@@ skipping 13 matching lines @@
   void SetIsPerClosure(const Instance& closure) {
     ASSERT(kind_ == kNone);
     kind_ = kPerClosure;
     closure_ = closure.raw();
   }
 
   // Mark that this breakpoint is a result of a step OverAwait request.
   void set_is_synthetic_async(bool is_synthetic_async) {
     is_synthetic_async_ = is_synthetic_async;
   }
-  bool is_synthetic_async() const {
-    return is_synthetic_async_;
-  }
+  bool is_synthetic_async() const { return is_synthetic_async_; }
 
   void PrintJSON(JSONStream* stream);
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   enum ConditionKind {
     kNone,
     kRepeated,
     kSingleShot,
@@ skipping 158 matching lines @@
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(CodeBreakpoint);
 };
 
 
 // ActivationFrame represents one dart function activation frame
 // on the call stack.
 class ActivationFrame : public ZoneAllocated {
  public:
-  ActivationFrame(uword pc, uword fp, uword sp, const Code& code,
-                  const Array& deopt_frame, intptr_t deopt_frame_offset);
+  ActivationFrame(uword pc,
+                  uword fp,
+                  uword sp,
+                  const Code& code,
+                  const Array& deopt_frame,
+                  intptr_t deopt_frame_offset);
 
   uword pc() const { return pc_; }
   uword fp() const { return fp_; }
   uword sp() const { return sp_; }
   const Function& function() const {
     ASSERT(!function_.IsNull());
     return function_;
   }
   const Code& code() const {
     ASSERT(!code_.IsNull());
@@ skipping 83 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) { }
+  explicit DebuggerStackTrace(int capacity) : trace_(capacity) {}
 
   intptr_t Length() const { return trace_.length(); }
 
-  ActivationFrame* FrameAt(int i) const {
-    return trace_[i];
-  }
+  ActivationFrame* FrameAt(int i) const { return trace_[i]; }
 
   ActivationFrame* GetHandlerFrame(const Instance& exc_obj) const;
 
  private:
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
@@ skipping 104 matching lines @@
   Dart_Port GetIsolateId() { return isolate_id_; }
 
   static void SetEventHandler(EventHandler* handler);
 
   // 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);
+  RawObject* GetStaticField(const Class& cls, const String& field_name);
 
   // Pause execution for a breakpoint.  Called from generated code.
   RawError* PauseBreakpoint();
 
   // Pause execution due to stepping.  Called from generated code.
   RawError* PauseStepping();
 
   // Pause execution due to isolate interrupt.
   RawError* PauseInterrupted();
 
@@ skipping 10 matching lines @@
   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
-  };
+  enum ResumeAction { kContinue, kStepOver, kStepOut, kSingleStep };
 
   RawError* PauseRequest(ServiceEvent::EventKind kind);
 
   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,
-                                       TokenPosition last_token_pos,
-                                       intptr_t requested_column);
+                                     TokenPosition requested_token_pos,
+                                     TokenPosition last_token_pos,
+                                     intptr_t requested_column);
   void DeoptimizeWorld();
   BreakpointLocation* SetBreakpoint(const Script& script,
                                     TokenPosition token_pos,
                                     TokenPosition last_token_pos,
                                     intptr_t requested_line,
                                     intptr_t requested_column);
   void RemoveInternalBreakpoints();
   void UnlinkCodeBreakpoints(BreakpointLocation* bpt_location);
   BreakpointLocation* GetLatentBreakpoint(const String& url,
                                           intptr_t line,
                                           intptr_t column);
   void RegisterBreakpointLocation(BreakpointLocation* bpt);
   void RegisterCodeBreakpoint(CodeBreakpoint* bpt);
   BreakpointLocation* GetBreakpointLocation(const Script& script,
                                             TokenPosition token_pos,
                                             intptr_t requested_column);
-  void MakeCodeBreakpointAt(const Function& func,
-                            BreakpointLocation* bpt);
+  void MakeCodeBreakpointAt(const Function& func, BreakpointLocation* bpt);
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
   void SyncBreakpointLocation(BreakpointLocation* loc);
 
   ActivationFrame* TopDartFrame() const;
   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 SignalPausedEvent(ActivationFrame* top_frame,
-                         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);
@@ skipping 57 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_