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

runtime/vm/profiler.h

 // 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.
 
 #ifndef RUNTIME_VM_PROFILER_H_
 #define RUNTIME_VM_PROFILER_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/code_observers.h"
@@ skipping 30 matching lines @@
   int64_t single_frame_sample_get_and_validate_stack_bounds;
   // Count of stack walkers used:
   int64_t stack_walker_native;
   int64_t stack_walker_dart_exit;
   int64_t stack_walker_dart;
   int64_t stack_walker_none;
   // Count of failed checks:
   int64_t failure_native_allocation_sample;
 };
 
-
 class Profiler : public AllStatic {
  public:
   static void InitOnce();
   static void InitAllocationSampleBuffer();
   static void Shutdown();
 
   static void SetSampleDepth(intptr_t depth);
   static void SetSamplePeriod(intptr_t period);
 
   static SampleBuffer* sample_buffer() { return sample_buffer_; }
@@ skipping 32 matching lines @@
   static bool initialized_;
 
   static SampleBuffer* sample_buffer_;
   static AllocationSampleBuffer* allocation_sample_buffer_;
 
   static ProfilerCounters counters_;
 
   friend class Thread;
 };
 
-
 class SampleVisitor : public ValueObject {
  public:
   explicit SampleVisitor(Dart_Port port) : port_(port), visited_(0) {}
   virtual ~SampleVisitor() {}
 
   virtual void VisitSample(Sample* sample) = 0;
 
   intptr_t visited() const { return visited_; }
 
   void IncrementVisited() { visited_++; }
 
   Dart_Port port() const { return port_; }
 
  private:
   Dart_Port port_;
   intptr_t visited_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SampleVisitor);
 };
 
-
 class SampleFilter : public ValueObject {
  public:
   SampleFilter(Dart_Port port,
                intptr_t thread_task_mask,
                int64_t time_origin_micros,
                int64_t time_extent_micros)
       : port_(port),
         thread_task_mask_(thread_task_mask),
         time_origin_micros_(time_origin_micros),
         time_extent_micros_(time_extent_micros) {
@@ skipping 17 matching lines @@
 
   static const intptr_t kNoTaskFilter = -1;
 
  private:
   Dart_Port port_;
   intptr_t thread_task_mask_;
   int64_t time_origin_micros_;
   int64_t time_extent_micros_;
 };
 
-
 class ClearProfileVisitor : public SampleVisitor {
  public:
   explicit ClearProfileVisitor(Isolate* isolate);
 
   virtual void VisitSample(Sample* sample);
 };
 
-
 // Each Sample holds a stack trace from an isolate.
 class Sample {
  public:
   void Init(Dart_Port port, int64_t timestamp, ThreadId tid) {
     Clear();
     timestamp_ = timestamp;
     tid_ = tid;
     port_ = port;
   }
 
@@ skipping 229 matching lines @@
   uword native_allocation_address_;
   uintptr_t native_allocation_size_bytes_;
   intptr_t continuation_index_;
   Sample* next_free_;
 
   /* There are a variable number of words that follow, the words hold the
    * sampled pc values. Access via GetPCArray() */
   DISALLOW_COPY_AND_ASSIGN(Sample);
 };
 
-
 class NativeAllocationSampleFilter : public SampleFilter {
  public:
   NativeAllocationSampleFilter(int64_t time_origin_micros,
                                int64_t time_extent_micros)
       : SampleFilter(ILLEGAL_PORT,
                      SampleFilter::kNoTaskFilter,
                      time_origin_micros,
                      time_extent_micros) {}
 
   bool FilterSample(Sample* sample) {
     // If the sample is an allocation sample, we need to check that the
     // memory at the address hasn't been freed, and if the address associated
     // with the allocation has been freed and then reissued.
     void* alloc_address =
         reinterpret_cast<void*>(sample->native_allocation_address());
     ASSERT(alloc_address != NULL);
     Sample* recorded_sample = MallocHooks::GetSample(alloc_address);
     return (sample == recorded_sample);
   }
 };
 
-
 // A Code object descriptor.
 class CodeDescriptor : public ZoneAllocated {
  public:
   explicit CodeDescriptor(const Code& code);
 
   uword Start() const;
 
   uword Size() const;
 
   int64_t CompileTimestamp() const;
@@ skipping 22 matching lines @@
       return 0;
     }
   }
 
  private:
   const Code& code_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeDescriptor);
 };
 
-
 // Fast lookup of Dart code objects.
 class CodeLookupTable : public ZoneAllocated {
  public:
   explicit CodeLookupTable(Thread* thread);
 
   intptr_t length() const { return code_objects_.length(); }
 
   const CodeDescriptor* At(intptr_t index) const {
     return code_objects_.At(index);
   }
 
   const CodeDescriptor* FindCode(uword pc) const;
 
  private:
   void Build(Thread* thread);
 
   void Add(const Code& code);
 
   // Code objects sorted by entry.
   ZoneGrowableArray<CodeDescriptor*> code_objects_;
 
   friend class CodeLookupTableBuilder;
 
   DISALLOW_COPY_AND_ASSIGN(CodeLookupTable);
 };
 
-
 // Ring buffer of Samples that is (usually) shared by many isolates.
 class SampleBuffer {
  public:
   static const intptr_t kDefaultBufferCapacity = 120000;  // 2 minutes @ 1000hz.
 
   explicit SampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
   virtual ~SampleBuffer();
 
   intptr_t capacity() const { return capacity_; }
 
@@ skipping 41 matching lines @@
 
   VirtualMemory* memory_;
   Sample* samples_;
   intptr_t capacity_;
   uintptr_t cursor_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SampleBuffer);
 };
 
-
 class AllocationSampleBuffer : public SampleBuffer {
  public:
   explicit AllocationSampleBuffer(intptr_t capacity = kDefaultBufferCapacity);
   virtual ~AllocationSampleBuffer();
 
   intptr_t ReserveSampleSlotLocked();
   virtual Sample* ReserveSample();
   virtual Sample* ReserveSampleAndLink(Sample* previous);
   void FreeAllocationSample(Sample* sample);
 
  private:
   Mutex* mutex_;
   Sample* free_sample_list_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationSampleBuffer);
 };
 
-
 // A |ProcessedSample| is a combination of 1 (or more) |Sample|(s) that have
 // been merged into a logical sample. The raw data may have been processed to
 // improve the quality of the stack trace.
 class ProcessedSample : public ZoneAllocated {
  public:
   ProcessedSample();
 
   // Add |pc| to stack trace.
   void Add(uword pc) { pcs_.Add(pc); }
 
@@ skipping 77 matching lines @@
   bool truncated_;
   bool first_frame_executing_;
   uword native_allocation_address_;
   uintptr_t native_allocation_size_bytes_;
   ProfileTrieNode* timeline_trie_;
 
   friend class SampleBuffer;
   DISALLOW_COPY_AND_ASSIGN(ProcessedSample);
 };
 
-
 // A collection of |ProcessedSample|s.
 class ProcessedSampleBuffer : public ZoneAllocated {
  public:
   ProcessedSampleBuffer();
 
   void Add(ProcessedSample* sample) { samples_.Add(sample); }
 
   intptr_t length() const { return samples_.length(); }
 
   ProcessedSample* At(intptr_t index) { return samples_.At(index); }
 
   const CodeLookupTable& code_lookup_table() const {
     return *code_lookup_table_;
   }
 
  private:
   ZoneGrowableArray<ProcessedSample*> samples_;
   CodeLookupTable* code_lookup_table_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessedSampleBuffer);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_H_