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

runtime/lib/stacktrace.cc

 // Copyright (c) 2013, 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 "lib/stacktrace.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/debugger.h"
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
 #include "vm/object_store.h"
@@ skipping 22 matching lines @@
 
   // Collect the frames.
   const intptr_t collected_frames_count = StackTraceUtils::CollectFrames(
       thread, code_array, pc_offset_array, 0, stack_trace_length, skip_frames);
 
   ASSERT(collected_frames_count == stack_trace_length);
 
   return StackTrace::New(code_array, pc_offset_array);
 }
 
-
 static RawStackTrace* CurrentStackTrace(
     Thread* thread,
     bool for_async_function,
     intptr_t skip_frames = 1,
     bool causal_async_stacks = FLAG_causal_async_stacks) {
   if (!causal_async_stacks) {
     // Return the synchronous stack trace.
     return CurrentSyncStackTrace(thread, skip_frames);
   }
 
@@ skipping 37 matching lines @@
       thread, code_array, pc_offset_array, write_cursor,
       synchronous_stack_trace_length, skip_frames);
 
   write_cursor += collected_frames_count;
 
   ASSERT(write_cursor == capacity);
 
   return StackTrace::New(code_array, pc_offset_array, async_stack_trace);
 }
 
-
 RawStackTrace* GetStackTraceForException() {
   Thread* thread = Thread::Current();
   return CurrentStackTrace(thread, false, 0);
 }
 
-
 DEFINE_NATIVE_ENTRY(StackTrace_current, 0) {
   return CurrentStackTrace(thread, false);
 }
 
-
 DEFINE_NATIVE_ENTRY(StackTrace_asyncStackTraceHelper, 1) {
   GET_NATIVE_ARGUMENT(Closure, async_op, arguments->NativeArgAt(0));
   if (!async_op.IsNull()) {
     if (FLAG_support_debugger) {
       Debugger* debugger = isolate->debugger();
       if (debugger != NULL) {
         debugger->MaybeAsyncStepInto(async_op);
       }
     }
   }
   return CurrentStackTrace(thread, true);
 }
 
-
 DEFINE_NATIVE_ENTRY(StackTrace_clearAsyncThreadStackTrace, 0) {
   thread->clear_async_stack_trace();
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(StackTrace_setAsyncThreadStackTrace, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(StackTrace, stack_trace,
                                arguments->NativeArgAt(0));
   thread->set_async_stack_trace(stack_trace);
   return Object::null();
 }
 
-
 static void AppendFrames(const GrowableObjectArray& code_list,
                          const GrowableObjectArray& pc_offset_list,
                          int skip_frames) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   while (frame != NULL) {
     if (frame->IsDartFrame()) {
       if (skip_frames > 0) {
         skip_frames--;
       } else {
         code = frame->LookupDartCode();
         offset = Smi::New(frame->pc() - code.PayloadStart());
         code_list.Add(code);
         pc_offset_list.Add(offset);
       }
     }
     frame = frames.NextFrame();
   }
 }
 
-
 // Creates a StackTrace object from the current stack.
 //
 // Skips the first skip_frames Dart frames.
 const StackTrace& GetCurrentStackTrace(int skip_frames) {
   const GrowableObjectArray& code_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   const GrowableObjectArray& pc_offset_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   AppendFrames(code_list, pc_offset_list, skip_frames);
   const Array& code_array = Array::Handle(Array::MakeFixedLength(code_list));
   const Array& pc_offset_array =
       Array::Handle(Array::MakeFixedLength(pc_offset_list));
   const StackTrace& stacktrace =
       StackTrace::Handle(StackTrace::New(code_array, pc_offset_array));
   return stacktrace;
 }
 
 }  // namespace dart