VM: Re-format to use at most one newline between functions

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"
 
 DECLARE_FLAG(bool, verbose_debug);
 
 // 'Trace Debugger' TD_Print.
 #if defined(_MSC_VER)
 #define TD_Print(format, ...)                                                  \
   if (FLAG_verbose_debug) Log::Current()->Print(format, __VA_ARGS__)
 #else
 #define TD_Print(format, ...)                                                  \
   if (FLAG_verbose_debug) Log::Current()->Print(format, ##__VA_ARGS__)
 #endif
 
-
 namespace dart {
 
 class CodeBreakpoint;
 class Isolate;
 class JSONArray;
 class JSONStream;
 class ObjectPointerVisitor;
 class RemoteObjectCache;
 class BreakpointLocation;
 class StackFrame;
@@ skipping 60 matching lines @@
   ConditionKind kind_;
   Breakpoint* next_;
   RawInstance* closure_;
   BreakpointLocation* bpt_location_;
   bool is_synthetic_async_;
 
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Breakpoint);
 };
 
-
 // BreakpointLocation represents a collection of breakpoint conditions at the
 // same token position in Dart source. There may be more than one CodeBreakpoint
 // object per BreakpointLocation.
 // An unresolved breakpoint is one where the underlying code has not
 // been compiled yet. Since the code has not been compiled, we don't know
 // the definitive source location yet. The requested source location may
 // change when the underlying code gets compiled.
 // A latent breakpoint represents a breakpoint location in Dart source
 // that is not loaded in the VM when the breakpoint is requested.
 // When a script with matching url is loaded, a latent breakpoint
@@ skipping 65 matching lines @@
 
   // Valid for resolved breakpoints:
   RawFunction* function_;
   intptr_t line_number_;
   intptr_t column_number_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(BreakpointLocation);
 };
 
-
 // CodeBreakpoint represents a location in compiled code. There may be
 // more than one CodeBreakpoint for one BreakpointLocation, e.g. when a
 // function gets compiled as a regular function and as a closure.
 class CodeBreakpoint {
  public:
   CodeBreakpoint(const Code& code,
                  TokenPosition token_pos,
                  uword pc,
                  RawPcDescriptors::Kind kind);
   ~CodeBreakpoint();
@@ skipping 41 matching lines @@
   // DebugBreak. This is an instruction that was replaced. DebugBreak
   // will execute it after the breakpoint.
   Instr saved_value_;
   Instr saved_value_fastsmi_;
 #endif
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(CodeBreakpoint);
 };
 
-
 // ActivationFrame represents one dart function activation frame
 // on the call stack.
 class ActivationFrame : public ZoneAllocated {
  public:
   enum Kind {
     kRegular,
     kAsyncSuspensionMarker,
     kAsyncCausal,
     kAsyncActivation,
   };
@@ skipping 148 matching lines @@
   bool vars_initialized_;
   LocalVarDescriptors& var_descriptors_;
   ZoneGrowableArray<intptr_t> desc_indices_;
   PcDescriptors& pc_desc_;
 
   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) {}
 
   intptr_t Length() const { return trace_.length(); }
 
   ActivationFrame* FrameAt(int i) const { return trace_[i]; }
 
   ActivationFrame* GetHandlerFrame(const Instance& exc_obj) const;
 
  private:
   void AddActivation(ActivationFrame* frame);
   void AddMarker(ActivationFrame::Kind marker);
   void AddAsyncCausalFrame(uword pc, const Code& code);
 
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(DebuggerStackTrace);
 };
 
-
 class Debugger {
  public:
   enum ResumeAction {
     kContinue,
     kStepInto,
     kStepOver,
     kStepOut,
     kStepRewind,
     kStepOverAsyncSuspension,
   };
@@ skipping 254 matching lines @@
   void Pause(ServiceEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                              bool skip_next_step = false);
 
   void CacheStackTraces(DebuggerStackTrace* stack_trace,
                         DebuggerStackTrace* async_causal_stack_trace,
                         DebuggerStackTrace* awaiter_stack_trace);
   void ClearCachedStackTraces();
 
-
   // Can we rewind to the indicated frame?
   bool CanRewindFrame(intptr_t frame_index, const char** error) const;
 
   void RewindToFrame(intptr_t frame_index);
   void RewindToUnoptimizedFrame(StackFrame* frame, const Code& code);
   void RewindToOptimizedFrame(StackFrame* frame,
                               const Code& code,
                               intptr_t post_deopt_frame_index);
 
   void ResetSteppingFramePointers();
@@ skipping 59 matching lines @@
 
   Dart_ExceptionPauseInfo exc_pause_info_;
 
   static EventHandler* event_handler_;
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_