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

runtime/vm/profiler_service.cc

 // 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.
 
 #include "vm/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/log.h"
 #include "vm/malloc_hooks.h"
@@ skipping 73 matching lines @@
     }
     return size;
   }
 
   // Array holding code that is being kept around only for the profiler.
   const GrowableObjectArray& previous_;
   // Array holding code that should continue to be kept around for the profiler.
   const GrowableObjectArray& current_;
 };
 
-
 ProfileFunctionSourcePosition::ProfileFunctionSourcePosition(
     TokenPosition token_pos)
     : token_pos_(token_pos), exclusive_ticks_(0), inclusive_ticks_(0) {}
 
-
 void ProfileFunctionSourcePosition::Tick(bool exclusive) {
   if (exclusive) {
     exclusive_ticks_++;
   } else {
     inclusive_ticks_++;
   }
 }
 
-
 ProfileFunction::ProfileFunction(Kind kind,
                                  const char* name,
                                  const Function& function,
                                  const intptr_t table_index)
     : kind_(kind),
       name_(name),
       function_(Function::ZoneHandle(function.raw())),
       table_index_(table_index),
       profile_codes_(0),
       source_position_ticks_(0),
       exclusive_ticks_(0),
       inclusive_ticks_(0),
       inclusive_serial_(-1) {
   ASSERT((kind_ != kDartFunction) || !function_.IsNull());
   ASSERT((kind_ != kDartFunction) || (table_index_ >= 0));
   ASSERT(profile_codes_.length() == 0);
 }
 
-
 const char* ProfileFunction::Name() const {
   if (name_ != NULL) {
     return name_;
   }
   ASSERT(!function_.IsNull());
   const String& func_name =
       String::Handle(function_.QualifiedUserVisibleName());
   return func_name.ToCString();
 }
 
-
 bool ProfileFunction::is_visible() const {
   if (function_.IsNull()) {
     // Some synthetic function.
     return true;
   }
   return FLAG_show_invisible_frames || function_.is_visible();
 }
 
-
 void ProfileFunction::Tick(bool exclusive,
                            intptr_t inclusive_serial,
                            TokenPosition token_position) {
   if (exclusive) {
     exclusive_ticks_++;
     TickSourcePosition(token_position, exclusive);
   }
   // Fall through and tick inclusive count too.
   if (inclusive_serial_ == inclusive_serial) {
     // Already ticked.
     return;
   }
   inclusive_serial_ = inclusive_serial;
   inclusive_ticks_++;
   TickSourcePosition(token_position, false);
 }
 
-
 void ProfileFunction::TickSourcePosition(TokenPosition token_position,
                                          bool exclusive) {
   intptr_t i = 0;
   for (; i < source_position_ticks_.length(); i++) {
     ProfileFunctionSourcePosition& position = source_position_ticks_[i];
     if (position.token_pos().value() == token_position.value()) {
       if (FLAG_trace_profiler_verbose) {
         OS::Print("Ticking source position %s %s\n",
                   exclusive ? "exclusive" : "inclusive",
                   token_position.ToCString());
@@ skipping 16 matching lines @@
   }
   pfsp.Tick(exclusive);
 
   if (i < source_position_ticks_.length()) {
     source_position_ticks_.InsertAt(i, pfsp);
   } else {
     source_position_ticks_.Add(pfsp);
   }
 }
 
-
 const char* ProfileFunction::KindToCString(Kind kind) {
   switch (kind) {
     case kDartFunction:
       return "Dart";
     case kNativeFunction:
       return "Native";
     case kTagFunction:
       return "Tag";
     case kStubFunction:
       return "Stub";
     case kUnknownFunction:
       return "Collected";
     default:
       UNIMPLEMENTED();
       return "";
   }
 }
 
-
 void ProfileFunction::PrintToJSONObject(JSONObject* func) {
   func->AddProperty("type", "@Function");
   func->AddProperty("name", name());
   func->AddProperty("_kind", KindToCString(kind()));
 }
 
-
 void ProfileFunction::PrintToJSONArray(JSONArray* functions) {
   JSONObject obj(functions);
   obj.AddProperty("kind", KindToCString(kind()));
   obj.AddProperty("inclusiveTicks", inclusive_ticks());
   obj.AddProperty("exclusiveTicks", exclusive_ticks());
   if (kind() == kDartFunction) {
     ASSERT(!function_.IsNull());
     obj.AddProperty("function", function_);
   } else {
     JSONObject func(&obj, "function");
     PrintToJSONObject(&func);
   }
   {
     JSONArray codes(&obj, "codes");
     for (intptr_t i = 0; i < profile_codes_.length(); i++) {
       intptr_t code_index = profile_codes_[i];
       codes.AddValue(code_index);
     }
   }
 }
 
-
 void ProfileFunction::AddProfileCode(intptr_t code_table_index) {
   for (intptr_t i = 0; i < profile_codes_.length(); i++) {
     if (profile_codes_[i] == code_table_index) {
       return;
     }
   }
   profile_codes_.Add(code_table_index);
 }
 
-
 bool ProfileFunction::GetSinglePosition(ProfileFunctionSourcePosition* pfsp) {
   if (pfsp == NULL) {
     return false;
   }
   if (source_position_ticks_.length() != 1) {
     return false;
   }
   *pfsp = source_position_ticks_[0];
   return true;
 }
 
-
 ProfileCodeAddress::ProfileCodeAddress(uword pc)
     : pc_(pc), exclusive_ticks_(0), inclusive_ticks_(0) {}
 
-
 void ProfileCodeAddress::Tick(bool exclusive) {
   if (exclusive) {
     exclusive_ticks_++;
   } else {
     inclusive_ticks_++;
   }
 }
 
-
 ProfileCode::ProfileCode(Kind kind,
                          uword start,
                          uword end,
                          int64_t timestamp,
                          const Code& code)
     : kind_(kind),
       start_(start),
       end_(end),
       exclusive_ticks_(0),
       inclusive_ticks_(0),
       inclusive_serial_(-1),
       code_(code),
       name_(NULL),
       compile_timestamp_(0),
       function_(NULL),
       code_table_index_(-1),
       address_ticks_(0) {}
 
-
 void ProfileCode::TruncateLower(uword start) {
   if (start > start_) {
     start_ = start;
   }
   ASSERT(start_ < end_);
 }
 
-
 void ProfileCode::TruncateUpper(uword end) {
   if (end < end_) {
     end_ = end;
   }
   ASSERT(start_ < end_);
 }
 
-
 void ProfileCode::ExpandLower(uword start) {
   if (start < start_) {
     start_ = start;
   }
   ASSERT(start_ < end_);
 }
 
-
 void ProfileCode::ExpandUpper(uword end) {
   if (end > end_) {
     end_ = end;
   }
   ASSERT(start_ < end_);
 }
 
-
 bool ProfileCode::Overlaps(const ProfileCode* other) const {
   ASSERT(other != NULL);
   return other->Contains(start_) || other->Contains(end_ - 1) ||
          Contains(other->start()) || Contains(other->end() - 1);
 }
 
-
 bool ProfileCode::IsOptimizedDart() const {
   return !code_.IsNull() && code_.is_optimized();
 }
 
-
 void ProfileCode::SetName(const char* name) {
   if (name == NULL) {
     name_ = NULL;
   }
   intptr_t len = strlen(name);
   name_ = Thread::Current()->zone()->Alloc<char>(len + 1);
   strncpy(name_, name, len);
   name_[len] = '\0';
 }
 
-
 void ProfileCode::GenerateAndSetSymbolName(const char* prefix) {
   const intptr_t kBuffSize = 512;
   char buff[kBuffSize];
   OS::SNPrint(&buff[0], kBuffSize - 1, "%s [%" Px ", %" Px ")", prefix, start(),
               end());
   SetName(buff);
 }
 
-
 void ProfileCode::Tick(uword pc, bool exclusive, intptr_t serial) {
   // If exclusive is set, tick it.
   if (exclusive) {
     exclusive_ticks_++;
     TickAddress(pc, true);
   }
   // Fall through and tick inclusive count too.
   if (inclusive_serial_ == serial) {
     // Already gave inclusive tick for this sample.
     return;
   }
   inclusive_serial_ = serial;
   inclusive_ticks_++;
   TickAddress(pc, false);
 }
 
-
 void ProfileCode::TickAddress(uword pc, bool exclusive) {
   const intptr_t length = address_ticks_.length();
 
   intptr_t i = 0;
   for (; i < length; i++) {
     ProfileCodeAddress& entry = address_ticks_[i];
     if (entry.pc() == pc) {
       // Tick the address entry.
       entry.Tick(exclusive);
       return;
@@ skipping 10 matching lines @@
 
   if (i < length) {
     // Insert at i.
     address_ticks_.InsertAt(i, entry);
   } else {
     // Add to end.
     address_ticks_.Add(entry);
   }
 }
 
-
 void ProfileCode::PrintNativeCode(JSONObject* profile_code_obj) {
   ASSERT(kind() == kNativeCode);
   JSONObject obj(profile_code_obj, "code");
   obj.AddProperty("type", "@Code");
   obj.AddProperty("kind", "Native");
   obj.AddProperty("name", name());
   obj.AddProperty("_optimized", false);
   obj.AddPropertyF("start", "%" Px "", start());
   obj.AddPropertyF("end", "%" Px "", end());
   {
     // Generate a fake function entry.
     JSONObject func(&obj, "function");
     ASSERT(function_ != NULL);
     function_->PrintToJSONObject(&func);
   }
 }
 
-
 void ProfileCode::PrintCollectedCode(JSONObject* profile_code_obj) {
   ASSERT(kind() == kCollectedCode);
   JSONObject obj(profile_code_obj, "code");
   obj.AddProperty("type", "@Code");
   obj.AddProperty("kind", "Collected");
   obj.AddProperty("name", name());
   obj.AddProperty("_optimized", false);
   obj.AddPropertyF("start", "%" Px "", start());
   obj.AddPropertyF("end", "%" Px "", end());
   {
     // Generate a fake function entry.
     JSONObject func(&obj, "function");
     ASSERT(function_ != NULL);
     function_->PrintToJSONObject(&func);
   }
 }
 
-
 void ProfileCode::PrintOverwrittenCode(JSONObject* profile_code_obj) {
   ASSERT(kind() == kReusedCode);
   JSONObject obj(profile_code_obj, "code");
   obj.AddProperty("type", "@Code");
   obj.AddProperty("kind", "Collected");
   obj.AddProperty("name", name());
   obj.AddProperty("_optimized", false);
   obj.AddPropertyF("start", "%" Px "", start());
   obj.AddPropertyF("end", "%" Px "", end());
   {
     // Generate a fake function entry.
     JSONObject func(&obj, "function");
     ASSERT(function_ != NULL);
     function_->PrintToJSONObject(&func);
   }
 }
 
-
 void ProfileCode::PrintTagCode(JSONObject* profile_code_obj) {
   ASSERT(kind() == kTagCode);
   JSONObject obj(profile_code_obj, "code");
   obj.AddProperty("type", "@Code");
   obj.AddProperty("kind", "Tag");
   obj.AddProperty("name", name());
   obj.AddPropertyF("start", "%" Px "", start());
   obj.AddPropertyF("end", "%" Px "", end());
   obj.AddProperty("_optimized", false);
   {
     // Generate a fake function entry.
     JSONObject func(&obj, "function");
     ASSERT(function_ != NULL);
     function_->PrintToJSONObject(&func);
   }
 }
 
-
 const char* ProfileCode::KindToCString(Kind kind) {
   switch (kind) {
     case kDartCode:
       return "Dart";
     case kCollectedCode:
       return "Collected";
     case kNativeCode:
       return "Native";
     case kReusedCode:
       return "Overwritten";
     case kTagCode:
       return "Tag";
   }
   UNREACHABLE();
   return NULL;
 }
 
-
 void ProfileCode::PrintToJSONArray(JSONArray* codes) {
   JSONObject obj(codes);
   obj.AddProperty("kind", ProfileCode::KindToCString(kind()));
   obj.AddProperty("inclusiveTicks", inclusive_ticks());
   obj.AddProperty("exclusiveTicks", exclusive_ticks());
   if (kind() == kDartCode) {
     ASSERT(!code_.IsNull());
     obj.AddProperty("code", code_);
   } else if (kind() == kCollectedCode) {
     PrintCollectedCode(&obj);
   } else if (kind() == kReusedCode) {
     PrintOverwrittenCode(&obj);
   } else if (kind() == kTagCode) {
     PrintTagCode(&obj);
   } else {
     ASSERT(kind() == kNativeCode);
     PrintNativeCode(&obj);
   }
   {
     JSONArray ticks(&obj, "ticks");
     for (intptr_t i = 0; i < address_ticks_.length(); i++) {
       const ProfileCodeAddress& entry = address_ticks_[i];
       ticks.AddValueF("%" Px "", entry.pc());
       ticks.AddValue(entry.exclusive_ticks());
       ticks.AddValue(entry.inclusive_ticks());
     }
   }
 }
 
-
 class ProfileFunctionTable : public ZoneAllocated {
  public:
   ProfileFunctionTable()
       : null_function_(Function::ZoneHandle()),
         unknown_function_(NULL),
         table_(8) {
     unknown_function_ =
         Add(ProfileFunction::kUnknownFunction, "<unknown Dart function>");
   }
 
@@ skipping 77 matching lines @@
       return kv->function()->raw() == key->raw();
     }
   };
 
   const Function& null_function_;
   ProfileFunction* unknown_function_;
   ZoneGrowableArray<ProfileFunction*> table_;
   DirectChainedHashMap<ProfileFunctionTableTrait> function_hash_;
 };
 
-
 ProfileFunction* ProfileCode::SetFunctionAndName(ProfileFunctionTable* table) {
   ASSERT(function_ == NULL);
 
   ProfileFunction* function = NULL;
   if ((kind() == kReusedCode) || (kind() == kCollectedCode)) {
     if (name() == NULL) {
       // Lazily set generated name.
       GenerateAndSetSymbolName("[Collected]");
     }
     // Map these to a canonical unknown function.
@@ skipping 63 matching lines @@
     UNREACHABLE();
   }
   ASSERT(function != NULL);
 
   function->AddProfileCode(code_table_index());
 
   function_ = function;
   return function_;
 }
 
-
 intptr_t ProfileCodeTable::FindCodeIndexForPC(uword pc) const {
   intptr_t length = table_.length();
   if (length == 0) {
     return -1;  // Not found.
   }
   intptr_t lo = 0;
   intptr_t hi = length - 1;
   while (lo <= hi) {
     intptr_t mid = (hi - lo + 1) / 2 + lo;
     ASSERT(mid >= lo);
     ASSERT(mid <= hi);
     ProfileCode* code = At(mid);
     if (code->Contains(pc)) {
       return mid;
     } else if (pc < code->start()) {
       hi = mid - 1;
     } else {
       lo = mid + 1;
     }
   }
   return -1;
 }
 
-
 intptr_t ProfileCodeTable::InsertCode(ProfileCode* new_code) {
   const intptr_t length = table_.length();
   if (length == 0) {
     table_.Add(new_code);
     return length;
   }
 
   // Determine the correct place to insert or merge |new_code| into table.
   intptr_t lo = -1;
   intptr_t hi = -1;
@@ skipping 39 matching lines @@
     insert = 0;
   } else if (hi == -1) {
     insert = length;
   } else {
     insert = lo + 1;
   }
   table_.InsertAt(insert, new_code);
   return insert;
 }
 
-
 void ProfileCodeTable::FindNeighbors(uword pc,
                                      intptr_t* lo,
                                      intptr_t* hi,
                                      ProfileCode** lo_code,
                                      ProfileCode** hi_code) const {
   ASSERT(table_.length() >= 1);
 
   intptr_t length = table_.length();
 
   if (pc < At(0)->start()) {
@@ skipping 28 matching lines @@
       *lo = mid;
       *lo_code = code;
     }
     if (pc < code->end()) {
       *hi = mid;
       *hi_code = code;
     }
   }
 }
 
-
 void ProfileCodeTable::VerifyOrder() {
   const intptr_t length = table_.length();
   if (length == 0) {
     return;
   }
   uword last = table_[0]->end();
   for (intptr_t i = 1; i < length; i++) {
     ProfileCode* a = table_[i];
     ASSERT(last <= a->start());
     last = a->end();
   }
 }
 
 void ProfileCodeTable::VerifyOverlap() {
   const intptr_t length = table_.length();
   for (intptr_t i = 0; i < length; i++) {
     ProfileCode* a = table_[i];
     for (intptr_t j = i + 1; j < length; j++) {
       ProfileCode* b = table_[j];
       ASSERT(!a->Contains(b->start()) && !a->Contains(b->end() - 1) &&
              !b->Contains(a->start()) && !b->Contains(a->end() - 1));
     }
   }
 }
 
-
 ProfileTrieNode::ProfileTrieNode(intptr_t table_index)
     : table_index_(table_index),
       count_(0),
       exclusive_allocations_(0),
       inclusive_allocations_(0),
       children_(0),
       frame_id_(-1) {
   ASSERT(table_index_ >= 0);
 }
 
-
 ProfileTrieNode::~ProfileTrieNode() {}
 
-
 void ProfileTrieNode::Tick(ProcessedSample* sample, bool exclusive) {
   count_++;
   IncrementAllocation(sample->native_allocation_size_bytes(), exclusive);
 }
 
-
 void ProfileTrieNode::SortChildren() {
   children_.Sort(ProfileTrieNodeCompare);
   // Recurse.
   for (intptr_t i = 0; i < children_.length(); i++) {
     children_[i]->SortChildren();
   }
 }
 
-
 intptr_t ProfileTrieNode::IndexOf(ProfileTrieNode* node) {
   for (intptr_t i = 0; i < children_.length(); i++) {
     if (children_[i] == node) {
       return i;
     }
   }
   return -1;
 }
 
-
 class ProfileCodeTrieNode : public ProfileTrieNode {
  public:
   explicit ProfileCodeTrieNode(intptr_t table_index)
       : ProfileTrieNode(table_index) {}
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
@@ skipping 30 matching lines @@
       // Insert at i.
       children_.InsertAt(i, reinterpret_cast<ProfileTrieNode*>(child));
     } else {
       // Add to end.
       children_.Add(reinterpret_cast<ProfileTrieNode*>(child));
     }
     return child;
   }
 };
 
-
 class ProfileFunctionTrieNodeCode {
  public:
   explicit ProfileFunctionTrieNodeCode(intptr_t index)
       : code_index_(index), ticks_(0) {}
 
   intptr_t index() const { return code_index_; }
 
   void Tick() { ticks_++; }
 
   intptr_t ticks() const { return ticks_; }
 
  private:
   intptr_t code_index_;
   intptr_t ticks_;
 };
 
-
 class ProfileFunctionTrieNode : public ProfileTrieNode {
  public:
   explicit ProfileFunctionTrieNode(intptr_t table_index)
       : ProfileTrieNode(table_index), code_objects_(1) {}
 
   void PrintToJSONArray(JSONArray* array) const {
     ASSERT(array != NULL);
     // Write CodeRegion index.
     array->AddValue(table_index());
     // Write count.
@@ skipping 55 matching lines @@
     }
     ProfileFunctionTrieNodeCode code_object(index);
     code_object.Tick();
     code_objects_.Add(code_object);
   }
 
  private:
   ZoneGrowableArray<ProfileFunctionTrieNodeCode> code_objects_;
 };
 
-
 class ProfileCodeInlinedFunctionsCache : public ValueObject {
  public:
   ProfileCodeInlinedFunctionsCache() : cache_cursor_(0), last_hit_(0) {
     for (intptr_t i = 0; i < kCacheSize; i++) {
       cache_[i].Reset();
     }
     cache_hit_ = 0;
     cache_miss_ = 0;
   }
 
@@ skipping 124 matching lines @@
   };
 
   static const intptr_t kCacheSize = 128;
   intptr_t cache_cursor_;
   intptr_t last_hit_;
   CacheEntry cache_[kCacheSize];
   intptr_t cache_miss_;
   intptr_t cache_hit_;
 };
 
-
 class ProfileBuilder : public ValueObject {
  public:
   enum ProfileInfoKind {
     kNone,
     kOptimized,
     kUnoptimized,
     kNative,
     kInlineStart,
     kInlineFinish,
     kNumProfileInfoKind,
@@ skipping 555 matching lines @@
     ProfileCodeTable* tag_table = profile_->tag_code_;
     intptr_t index = tag_table->FindCodeIndexForPC(VMTag::kTruncatedTagId);
     ASSERT(index >= 0);
     ProfileCode* code = tag_table->At(index);
     code->IncInclusiveTicks();
     ASSERT(code != NULL);
     ProfileFunction* function = code->function();
     function->IncInclusiveTicks();
   }
 
-
   // Tag append functions are overloaded for |ProfileCodeTrieNode| and
   // |ProfileFunctionTrieNode| types.
 
   // ProfileCodeTrieNode
   ProfileCodeTrieNode* AppendUserTag(uword user_tag,
                                      ProfileCodeTrieNode* current,
                                      ProcessedSample* sample) {
     intptr_t user_tag_index = GetProfileCodeTagIndex(user_tag);
     if (user_tag_index >= 0) {
       current = current->GetChild(user_tag_index);
@@ skipping 426 matching lines @@
     ProfileCode* code =
         new ProfileCode(ProfileCode::kReusedCode, pc, pc + 1, 0, null_code_);
     return code;
   }
 
   bool IsPCInDartHeap(uword pc) {
     return vm_isolate_->heap()->CodeContains(pc) ||
            thread_->isolate()->heap()->CodeContains(pc);
   }
 
-
   ProfileCode* FindOrRegisterNativeProfileCode(uword pc) {
     // Check if |pc| is already known in the live code table.
     ProfileCodeTable* live_table = profile_->live_code_;
     ProfileCode* profile_code = live_table->FindCodeForPC(pc);
     if (profile_code != NULL) {
       return profile_code;
     }
 
     // We haven't seen this pc yet.
     Code& code = Code::Handle(thread_->zone());
@@ skipping 99 matching lines @@
   DeoptimizedCodeSet* deoptimized_code_;
   const Code& null_code_;
   const Function& null_function_;
   bool tick_functions_;
   bool inclusive_tree_;
   ProfileCodeInlinedFunctionsCache inlined_functions_cache_;
   ProcessedSampleBuffer* samples_;
   ProfileInfoKind info_kind_;
 };  // ProfileBuilder.
 
-
 Profile::Profile(Isolate* isolate)
     : isolate_(isolate),
       zone_(Thread::Current()->zone()),
       samples_(NULL),
       live_code_(NULL),
       dead_code_(NULL),
       tag_code_(NULL),
       functions_(NULL),
       dead_code_index_offset_(-1),
       tag_code_index_offset_(-1),
       min_time_(kMaxInt64),
       max_time_(0) {
   ASSERT(isolate_ != NULL);
   for (intptr_t i = 0; i < kNumTrieKinds; i++) {
     roots_[i] = NULL;
   }
 }
 
-
 void Profile::Build(Thread* thread,
                     SampleFilter* filter,
                     SampleBuffer* sample_buffer,
                     TagOrder tag_order,
                     intptr_t extra_tags) {
   ProfileBuilder builder(thread, filter, sample_buffer, tag_order, extra_tags,
                          this);
   builder.Build();
 }
 
-
 intptr_t Profile::NumFunctions() const {
   return functions_->length();
 }
 
 ProfileFunction* Profile::GetFunction(intptr_t index) {
   ASSERT(functions_ != NULL);
   return functions_->At(index);
 }
 
-
 ProfileCode* Profile::GetCode(intptr_t index) {
   ASSERT(live_code_ != NULL);
   ASSERT(dead_code_ != NULL);
   ASSERT(tag_code_ != NULL);
   ASSERT(dead_code_index_offset_ >= 0);
   ASSERT(tag_code_index_offset_ >= 0);
 
   // Code indexes span three arrays.
   //           0 ... |live_code|
   // |live_code| ... |dead_code|
   // |dead_code| ... |tag_code|
 
   if (index < dead_code_index_offset_) {
     return live_code_->At(index);
   }
 
   if (index < tag_code_index_offset_) {
     index -= dead_code_index_offset_;
     return dead_code_->At(index);
   }
 
   index -= tag_code_index_offset_;
   return tag_code_->At(index);
 }
 
-
 ProfileTrieNode* Profile::GetTrieRoot(TrieKind trie_kind) {
   return roots_[static_cast<intptr_t>(trie_kind)];
 }
 
-
 void Profile::PrintHeaderJSON(JSONObject* obj) {
   obj->AddProperty("samplePeriod", static_cast<intptr_t>(FLAG_profile_period));
   obj->AddProperty("stackDepth", static_cast<intptr_t>(FLAG_max_profile_depth));
   obj->AddProperty("sampleCount", sample_count());
   obj->AddProperty("timeSpan", MicrosecondsToSeconds(GetTimeSpan()));
   obj->AddPropertyTimeMicros("timeOriginMicros", min_time());
   obj->AddPropertyTimeMicros("timeExtentMicros", GetTimeSpan());
 
   ProfilerCounters counters = Profiler::counters();
   {
@@ skipping 12 matching lines @@
         "single_frame_sample_get_and_validate_stack_bounds",
         counters.single_frame_sample_get_and_validate_stack_bounds);
     counts.AddProperty64("stack_walker_native", counters.stack_walker_native);
     counts.AddProperty64("stack_walker_dart_exit",
                          counters.stack_walker_dart_exit);
     counts.AddProperty64("stack_walker_dart", counters.stack_walker_dart);
     counts.AddProperty64("stack_walker_none", counters.stack_walker_none);
   }
 }
 
-
 void Profile::PrintTimelineFrameJSON(JSONObject* frames,
                                      ProfileTrieNode* current,
                                      ProfileTrieNode* parent,
                                      intptr_t* next_id) {
   ASSERT(current->frame_id() == -1);
   const intptr_t id = *next_id;
   *next_id = id + 1;
   current->set_frame_id(id);
   ASSERT(current->frame_id() != -1);
 
@@ skipping 13 matching lines @@
                          parent->frame_id());
     }
   }
 
   for (intptr_t i = 0; i < current->NumChildren(); i++) {
     ProfileTrieNode* child = current->At(i);
     PrintTimelineFrameJSON(frames, child, current, next_id);
   }
 }
 
-
 void Profile::PrintTimelineJSON(JSONStream* stream) {
   ScopeTimer sw("Profile::PrintTimelineJSON", FLAG_trace_profiler);
   JSONObject obj(stream);
   obj.AddProperty("type", "_CpuProfileTimeline");
   PrintHeaderJSON(&obj);
   {
     JSONObject frames(&obj, "stackFrames");
     ProfileTrieNode* root = GetTrieRoot(kInclusiveFunction);
     intptr_t next_id = 0;
     PrintTimelineFrameJSON(&frames, root, NULL, &next_id);
@@ skipping 14 matching lines @@
       event.AddPropertyTimeMicros("ts", sample->timestamp());
       event.AddProperty("cat", "Dart");
 
       ProfileTrieNode* trie = sample->timeline_trie();
       ASSERT(trie->frame_id() != -1);
       event.AddPropertyF("sf", "%" Pd "-%" Pd, isolate_id, trie->frame_id());
     }
   }
 }
 
-
 ProfileFunction* Profile::FindFunction(const Function& function) {
   return (functions_ != NULL) ? functions_->Lookup(function) : NULL;
 }
 
-
 void Profile::PrintProfileJSON(JSONStream* stream) {
   ScopeTimer sw("Profile::PrintProfileJSON", FLAG_trace_profiler);
   JSONObject obj(stream);
   obj.AddProperty("type", "_CpuProfile");
   PrintHeaderJSON(&obj);
   {
     JSONArray codes(&obj, "codes");
     for (intptr_t i = 0; i < live_code_->length(); i++) {
       ProfileCode* code = live_code_->At(i);
       ASSERT(code != NULL);
@@ skipping 38 matching lines @@
     root->PrintToJSONArray(&function_trie);
   }
   {
     JSONArray function_trie(&obj, "inclusiveFunctionTrie");
     ProfileTrieNode* root = roots_[static_cast<intptr_t>(kInclusiveFunction)];
     ASSERT(root != NULL);
     root->PrintToJSONArray(&function_trie);
   }
 }
 
-
 void ProfileTrieWalker::Reset(Profile::TrieKind trie_kind) {
   code_trie_ = Profile::IsCodeTrie(trie_kind);
   parent_ = NULL;
   current_ = profile_->GetTrieRoot(trie_kind);
   ASSERT(current_ != NULL);
 }
 
-
 const char* ProfileTrieWalker::CurrentName() {
   if (current_ == NULL) {
     return NULL;
   }
   if (code_trie_) {
     ProfileCode* code = profile_->GetCode(current_->table_index());
     return code->name();
   } else {
     ProfileFunction* func = profile_->GetFunction(current_->table_index());
     return func->Name();
   }
   UNREACHABLE();
   return NULL;
 }
 
-
 intptr_t ProfileTrieWalker::CurrentNodeTickCount() {
   if (current_ == NULL) {
     return -1;
   }
   return current_->count();
 }
 
-
 intptr_t ProfileTrieWalker::CurrentInclusiveTicks() {
   if (current_ == NULL) {
     return -1;
   }
   if (code_trie_) {
     ProfileCode* code = profile_->GetCode(current_->table_index());
     return code->inclusive_ticks();
   } else {
     ProfileFunction* func = profile_->GetFunction(current_->table_index());
     return func->inclusive_ticks();
   }
   UNREACHABLE();
   return -1;
 }
 
-
 intptr_t ProfileTrieWalker::CurrentExclusiveTicks() {
   if (current_ == NULL) {
     return -1;
   }
   if (code_trie_) {
     ProfileCode* code = profile_->GetCode(current_->table_index());
     return code->exclusive_ticks();
   } else {
     ProfileFunction* func = profile_->GetFunction(current_->table_index());
     return func->exclusive_ticks();
   }
   UNREACHABLE();
   return -1;
 }
 
-
 intptr_t ProfileTrieWalker::CurrentInclusiveAllocations() {
   if (current_ == NULL) {
     return -1;
   }
   return current_->inclusive_allocations();
 }
 
-
 intptr_t ProfileTrieWalker::CurrentExclusiveAllocations() {
   if (current_ == NULL) {
     return -1;
   }
   return current_->exclusive_allocations();
 }
 
-
 const char* ProfileTrieWalker::CurrentToken() {
   if (current_ == NULL) {
     return NULL;
   }
   if (code_trie_) {
     return NULL;
   }
   ProfileFunction* func = profile_->GetFunction(current_->table_index());
   const Function& function = *(func->function());
   if (function.IsNull()) {
@@ skipping 40 matching lines @@
 
 bool ProfileTrieWalker::Down() {
   if ((current_ == NULL) || (current_->NumChildren() == 0)) {
     return false;
   }
   parent_ = current_;
   current_ = current_->At(0);
   return true;
 }
 
-
 bool ProfileTrieWalker::NextSibling() {
   if (parent_ == NULL) {
     return false;
   }
   intptr_t current_index = parent_->IndexOf(current_);
   if (current_index < 0) {
     return false;
   }
   current_index++;
   if (current_index >= parent_->NumChildren()) {
     return false;
   }
   current_ = parent_->At(current_index);
   return true;
 }
 
-
 intptr_t ProfileTrieWalker::SiblingCount() {
   ASSERT(parent_ != NULL);
   return parent_->NumChildren();
 }
 
-
 void ProfilerService::PrintJSONImpl(Thread* thread,
                                     JSONStream* stream,
                                     Profile::TagOrder tag_order,
                                     intptr_t extra_tags,
                                     SampleFilter* filter,
                                     SampleBuffer* sample_buffer,
                                     bool as_timeline) {
   Isolate* isolate = thread->isolate();
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   if (sample_buffer == NULL) {
     stream->PrintError(kFeatureDisabled, NULL);
     return;
   }
 
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     Profile profile(isolate);
     profile.Build(thread, filter, sample_buffer, tag_order, extra_tags);
     if (as_timeline) {
       profile.PrintTimelineJSON(stream);
     } else {
       profile.PrintProfileJSON(stream);
     }
   }
 }
 
-
 class NoAllocationSampleFilter : public SampleFilter {
  public:
   NoAllocationSampleFilter(Dart_Port port,
                            intptr_t thread_task_mask,
                            int64_t time_origin_micros,
                            int64_t time_extent_micros)
       : SampleFilter(port,
                      thread_task_mask,
                      time_origin_micros,
                      time_extent_micros) {}
 
   bool FilterSample(Sample* sample) { return !sample->is_allocation_sample(); }
 };
 
-
 void ProfilerService::PrintJSON(JSONStream* stream,
                                 Profile::TagOrder tag_order,
                                 intptr_t extra_tags,
                                 int64_t time_origin_micros,
                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   NoAllocationSampleFilter filter(isolate->main_port(), Thread::kMutatorTask,
                                   time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, extra_tags, &filter,
                 Profiler::sample_buffer(), as_timeline);
 }
 
-
 class ClassAllocationSampleFilter : public SampleFilter {
  public:
   ClassAllocationSampleFilter(Dart_Port port,
                               const Class& cls,
                               intptr_t thread_task_mask,
                               int64_t time_origin_micros,
                               int64_t time_extent_micros)
       : SampleFilter(port,
                      thread_task_mask,
                      time_origin_micros,
                      time_extent_micros),
         cls_(Class::Handle(cls.raw())) {
     ASSERT(!cls_.IsNull());
   }
 
   bool FilterSample(Sample* sample) {
     return sample->is_allocation_sample() &&
            (sample->allocation_cid() == cls_.id());
   }
 
  private:
   const Class& cls_;
 };
 
-
 void ProfilerService::PrintAllocationJSON(JSONStream* stream,
                                           Profile::TagOrder tag_order,
                                           const Class& cls,
                                           int64_t time_origin_micros,
                                           int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   ClassAllocationSampleFilter filter(isolate->main_port(), cls,
                                      Thread::kMutatorTask, time_origin_micros,
                                      time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
                 Profiler::sample_buffer(), as_timeline);
 }
 
-
 void ProfilerService::PrintNativeAllocationJSON(JSONStream* stream,
                                                 Profile::TagOrder tag_order,
                                                 int64_t time_origin_micros,
                                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   NativeAllocationSampleFilter filter(time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
                 Profiler::allocation_sample_buffer(), as_timeline);
 }
 
-
 void ProfilerService::PrintTimelineJSON(JSONStream* stream,
                                         Profile::TagOrder tag_order,
                                         int64_t time_origin_micros,
                                         int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   const intptr_t thread_task_mask = Thread::kMutatorTask |
                                     Thread::kCompilerTask |
                                     Thread::kSweeperTask | Thread::kMarkerTask;
   NoAllocationSampleFilter filter(isolate->main_port(), thread_task_mask,
                                   time_origin_micros, time_extent_micros);
   const bool as_timeline = true;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter,
                 Profiler::sample_buffer(), as_timeline);
 }
 
-
 void ProfilerService::ClearSamples() {
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
 
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
 
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart