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

runtime/vm/timeline.h

 // Copyright (c) 2015, 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_TIMELINE_H_
 #define RUNTIME_VM_TIMELINE_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/allocation.h"
@@ skipping 119 matching lines @@
 #define TIMELINE_STREAM_DECLARE(name, not_used)                                \
   static bool stream_##name##_enabled_;                                        \
   static TimelineStream stream_##name##_;
   TIMELINE_STREAM_LIST(TIMELINE_STREAM_DECLARE)
 #undef TIMELINE_STREAM_DECLARE
 
   friend class TimelineRecorderOverride;
   friend class ReclaimBlocksIsolateVisitor;
 };
 
-
 struct TimelineEventArgument {
   const char* name;
   char* value;
 };
 
-
 // You should get a |TimelineEvent| from a |TimelineStream|.
 class TimelineEvent {
  public:
   // Keep in sync with StateBits below.
   enum EventType {
     kNone,
     kBegin,
     kEnd,
     kDuration,
     kInstant,
@@ skipping 232 matching lines @@
   friend class TimelineEventEndlessRecorder;
   friend class TimelineEventRingRecorder;
   friend class TimelineEventStartupRecorder;
   friend class TimelineEventSystraceRecorder;
   friend class TimelineEventFuchsiaRecorder;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   DISALLOW_COPY_AND_ASSIGN(TimelineEvent);
 };
 
-
 #ifndef PRODUCT
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, name, function)         \
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(), name);      \
   if (tds.enabled()) {                                                         \
     tds.SetNumArguments(1);                                                    \
     tds.CopyArgument(0, "function",                                            \
                      function.ToLibNamePrefixedQualifiedCString());            \
   }
 
 #define TIMELINE_FUNCTION_GC_DURATION(thread, name)                            \
@@ skipping 44 matching lines @@
 
   TimelineStream* stream_;
   const char* label_;
   TimelineEventArgument* arguments_;
   intptr_t arguments_length_;
   bool enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TimelineEventScope);
 };
 
-
 class TimelineDurationScope : public TimelineEventScope {
  public:
   TimelineDurationScope(TimelineStream* stream, const char* label);
 
   TimelineDurationScope(Thread* thread,
                         TimelineStream* stream,
                         const char* label);
 
   virtual ~TimelineDurationScope();
 
  private:
   int64_t timestamp_;
   int64_t thread_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(TimelineDurationScope);
 };
 
-
 class TimelineBeginEndScope : public TimelineEventScope {
  public:
   TimelineBeginEndScope(TimelineStream* stream, const char* label);
 
   TimelineBeginEndScope(Thread* thread,
                         TimelineStream* stream,
                         const char* label);
 
   virtual ~TimelineBeginEndScope();
 
  private:
   void EmitBegin();
   void EmitEnd();
 
   DISALLOW_COPY_AND_ASSIGN(TimelineBeginEndScope);
 };
 
-
 // A block of |TimelineEvent|s. Not thread safe.
 class TimelineEventBlock {
  public:
   static const intptr_t kBlockSize = 64;
 
   explicit TimelineEventBlock(intptr_t index);
   ~TimelineEventBlock();
 
   TimelineEventBlock* next() const { return next_; }
   void set_next(TimelineEventBlock* next) { next_ = next; }
@@ skipping 59 matching lines @@
   friend class TimelineEventStartupRecorder;
   friend class TimelineEventSystraceRecorder;
   friend class TimelineEventFuchsiaRecorder;
   friend class TimelineTestHelper;
   friend class JSONStream;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventBlock);
 };
 
-
 class TimelineEventFilter : public ValueObject {
  public:
   TimelineEventFilter(int64_t time_origin_micros = -1,
                       int64_t time_extent_micros = -1);
 
   virtual ~TimelineEventFilter();
 
   virtual bool IncludeBlock(TimelineEventBlock* block) {
     if (block == NULL) {
       return false;
@@ skipping 11 matching lines @@
 
   int64_t time_origin_micros() const { return time_origin_micros_; }
 
   int64_t time_extent_micros() const { return time_extent_micros_; }
 
  private:
   int64_t time_origin_micros_;
   int64_t time_extent_micros_;
 };
 
-
 class IsolateTimelineEventFilter : public TimelineEventFilter {
  public:
   explicit IsolateTimelineEventFilter(Dart_Port isolate_id,
                                       int64_t time_origin_micros = -1,
                                       int64_t time_extent_micros = -1);
 
   bool IncludeBlock(TimelineEventBlock* block) {
     if (block == NULL) {
       return false;
     }
     // Not empty, not in use, and isolate match.
     return !block->IsEmpty() && !block->in_use();
   }
 
   bool IncludeEvent(TimelineEvent* event) {
     return event->IsValid() && (event->isolate_id() == isolate_id_);
   }
 
  private:
   Dart_Port isolate_id_;
 };
 
-
 // Recorder of |TimelineEvent|s.
 class TimelineEventRecorder {
  public:
   TimelineEventRecorder();
   virtual ~TimelineEventRecorder() {}
 
   TimelineEventBlock* GetNewBlock();
 
   // Interface method(s) which must be implemented.
   virtual void PrintJSON(JSONStream* js, TimelineEventFilter* filter) = 0;
@@ skipping 31 matching lines @@
   friend class TimelineEvent;
   friend class TimelineEventBlockIterator;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   friend class Timeline;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventRecorder);
 };
 
-
 // An abstract recorder that stores events in a buffer of fixed capacity.
 class TimelineEventFixedBufferRecorder : public TimelineEventRecorder {
  public:
   static const intptr_t kDefaultCapacity = 8192;
 
   explicit TimelineEventFixedBufferRecorder(intptr_t capacity);
   virtual ~TimelineEventFixedBufferRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetHeadBlockLocked();
   intptr_t FindOldestBlockIndex() const;
   void Clear();
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter);
 
   TimelineEventBlock** blocks_;
   intptr_t capacity_;
   intptr_t num_blocks_;
   intptr_t block_cursor_;
 };
 
-
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events overwrite old events.
 class TimelineEventRingRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
   virtual ~TimelineEventRingRecorder() {}
 
   const char* name() const { return "Ring"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
 };
 
-
 // A recorder that writes events to Android Systrace. Events are also stored in
 // a buffer of fixed capacity. When the buffer is full, new events overwrite
 // old events.
 class TimelineEventSystraceRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventSystraceRecorder(intptr_t capacity = kDefaultCapacity);
   virtual ~TimelineEventSystraceRecorder();
 
   const char* name() const { return "Systrace"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
   void CompleteEvent(TimelineEvent* event);
 
   int systrace_fd_;
 };
 
-
 #if defined(HOST_OS_FUCHSIA)
 // A recorder that sends events to Fuchsia's tracing app. Events are also stored
 // in a buffer of fixed capacity. When the buffer is full, new events overwrite
 // old events.
 // See: https://fuchsia.googlesource.com/tracing/+/HEAD/docs/usage_guide.md
 class TimelineEventFuchsiaRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventFuchsiaRecorder(intptr_t capacity = kDefaultCapacity);
   virtual ~TimelineEventFuchsiaRecorder() {}
 
   const char* name() const { return "Fuchsia"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
   void CompleteEvent(TimelineEvent* event);
 };
 #endif  // defined(HOST_OS_FUCHSIA)
 
-
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events are dropped.
 class TimelineEventStartupRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventStartupRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
   virtual ~TimelineEventStartupRecorder() {}
 
   const char* name() const { return "Startup"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
 };
 
-
 // An abstract recorder that calls |OnEvent| whenever an event is complete.
 // This should only be used for testing.
 class TimelineEventCallbackRecorder : public TimelineEventRecorder {
  public:
   TimelineEventCallbackRecorder();
   virtual ~TimelineEventCallbackRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
   // Called when |event| is completed. It is unsafe to keep a reference to
   // |event| as it may be freed as soon as this function returns.
   virtual void OnEvent(TimelineEvent* event) = 0;
 
   const char* name() const { return "Callback"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked() { return NULL; }
   TimelineEventBlock* GetHeadBlockLocked() { return NULL; }
   void Clear() {}
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
 };
 
-
 // A recorder that stores events in chains of blocks of events.
 // NOTE: This recorder will continue to allocate blocks until it exhausts
 // memory.
 class TimelineEventEndlessRecorder : public TimelineEventRecorder {
  public:
   TimelineEventEndlessRecorder();
   virtual ~TimelineEventEndlessRecorder();
 
   void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
   void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
 
   const char* name() const { return "Endless"; }
 
  protected:
   TimelineEvent* StartEvent();
   void CompleteEvent(TimelineEvent* event);
   TimelineEventBlock* GetNewBlockLocked();
   TimelineEventBlock* GetHeadBlockLocked();
   void Clear();
 
   void PrintJSONEvents(JSONArray* array, TimelineEventFilter* filter);
 
   TimelineEventBlock* head_;
   intptr_t block_index_;
 
   friend class TimelineTestHelper;
 };
 
-
 // An iterator for blocks.
 class TimelineEventBlockIterator {
  public:
   explicit TimelineEventBlockIterator(TimelineEventRecorder* recorder);
   ~TimelineEventBlockIterator();
 
   void Reset(TimelineEventRecorder* recorder);
 
   // Returns false when there are no more blocks.
   bool HasNext() const;
 
   // Returns the next block and moves forward.
   TimelineEventBlock* Next();
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_H_