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

runtime/vm/profiler_service.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_PROFILER_SERVICE_H_
 #define RUNTIME_VM_PROFILER_SERVICE_H_
 
 #include "vm/allocation.h"
 #include "vm/code_observers.h"
 #include "vm/globals.h"
@@ skipping 32 matching lines @@
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
 
  private:
   TokenPosition token_pos_;
   intptr_t exclusive_ticks_;
   intptr_t inclusive_ticks_;
 
   DISALLOW_ALLOCATION();
 };
 
-
 // Profile data related to a |Function|.
 class ProfileFunction : public ZoneAllocated {
  public:
   enum Kind {
     kDartFunction,     // Dart function.
     kNativeFunction,   // Synthetic function for Native (C/C++).
     kTagFunction,      // Synthetic function for a VM or User tag.
     kStubFunction,     // Synthetic function for stub code.
     kUnknownFunction,  // A singleton function for unknown objects.
   };
@@ skipping 57 matching lines @@
   intptr_t inclusive_serial_;
 
   void PrintToJSONObject(JSONObject* func);
   // A |ProfileCode| that contains this function.
   void AddProfileCode(intptr_t code_table_index);
 
   friend class ProfileCode;
   friend class ProfileBuilder;
 };
 
-
 class ProfileCodeAddress {
  public:
   explicit ProfileCodeAddress(uword pc);
 
   void Tick(bool exclusive);
 
   uword pc() const { return pc_; }
   intptr_t exclusive_ticks() const { return exclusive_ticks_; }
   intptr_t inclusive_ticks() const { return inclusive_ticks_; }
 
  private:
   uword pc_;
   intptr_t exclusive_ticks_;
   intptr_t inclusive_ticks_;
 };
 
-
 // Profile data related to a |Code|.
 class ProfileCode : public ZoneAllocated {
  public:
   enum Kind {
     kDartCode,       // Live Dart code.
     kCollectedCode,  // Dead Dart code.
     kNativeCode,     // Native code.
     kReusedCode,     // Dead Dart code that has been reused by new kDartCode.
     kTagCode,        // A special kind of code representing a tag.
   };
@@ skipping 75 matching lines @@
   const Code& code_;
   char* name_;
   int64_t compile_timestamp_;
   ProfileFunction* function_;
   intptr_t code_table_index_;
   ZoneGrowableArray<ProfileCodeAddress> address_ticks_;
 
   friend class ProfileBuilder;
 };
 
-
 class ProfileCodeTable : public ZoneAllocated {
  public:
   ProfileCodeTable() : table_(8) {}
 
   intptr_t length() const { return table_.length(); }
 
   ProfileCode* At(intptr_t index) const {
     ASSERT(index >= 0);
     ASSERT(index < length());
     return table_[index];
@@ skipping 21 matching lines @@
                      intptr_t* hi,
                      ProfileCode** lo_code,
                      ProfileCode** hi_code) const;
 
   void VerifyOrder();
   void VerifyOverlap();
 
   ZoneGrowableArray<ProfileCode*> table_;
 };
 
-
 // Stack traces are organized in a trie. This holds information about one node
 // in the trie. A node in a tree represents a stack frame and a path in the tree
 // represents a stack trace. Each unique stack trace appears in the tree once
 // and each node has a count indicating how many times this has been observed.
 // The index can be used to look up a |ProfileFunction| or |ProfileCode|.
 // A node can have zero or more children. Depending on the kind of trie the
 // children are callers or callees of the current node.
 class ProfileTrieNode : public ZoneAllocated {
  public:
   explicit ProfileTrieNode(intptr_t index);
@@ skipping 34 matching lines @@
  protected:
   void SortChildren();
 
   static int ProfileTrieNodeCompare(ProfileTrieNode* const* a,
                                     ProfileTrieNode* const* b) {
     ASSERT(a != NULL);
     ASSERT(b != NULL);
     return (*b)->count() - (*a)->count();
   }
 
-
   intptr_t table_index_;
   intptr_t count_;
   intptr_t exclusive_allocations_;
   intptr_t inclusive_allocations_;
   ZoneGrowableArray<ProfileTrieNode*> children_;
   intptr_t frame_id_;
 
   friend class ProfileBuilder;
 };
 
-
 // The model for a profile. Most of the model is zone allocated, therefore
 // a zone must be created that lives longer than this object.
 class Profile : public ValueObject {
  public:
   enum TagOrder { kNoTags, kUser, kUserVM, kVM, kVMUser };
 
   enum TrieKind {
     kExclusiveCode,
     kExclusiveFunction,
     kInclusiveCode,
@@ skipping 53 matching lines @@
   ProfileTrieNode* roots_[kNumTrieKinds];
 
   int64_t min_time_;
   int64_t max_time_;
 
   intptr_t sample_count_;
 
   friend class ProfileBuilder;
 };
 
-
 class ProfileTrieWalker : public ValueObject {
  public:
   explicit ProfileTrieWalker(Profile* profile)
       : profile_(profile), parent_(NULL), current_(NULL), code_trie_(false) {
     ASSERT(profile_ != NULL);
   }
 
   void Reset(Profile::TrieKind trie_kind);
 
   const char* CurrentName();
@@ skipping 19 matching lines @@
   bool Down();
   bool NextSibling();
 
  private:
   Profile* profile_;
   ProfileTrieNode* parent_;
   ProfileTrieNode* current_;
   bool code_trie_;
 };
 
-
 class ProfilerService : public AllStatic {
  public:
   enum {
     kNoExtraTags = 0,
     kCodeTransitionTagsBit = (1 << 0),
   };
 
   static void PrintJSON(JSONStream* stream,
                         Profile::TagOrder tag_order,
                         intptr_t extra_tags,
@@ skipping 24 matching lines @@
                             Profile::TagOrder tag_order,
                             intptr_t extra_tags,
                             SampleFilter* filter,
                             SampleBuffer* sample_buffer,
                             bool as_timline);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PROFILER_SERVICE_H_