clang-format runtime/vm

runtime/vm/timeline_analysis.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_ANALYSIS_H_
 #define RUNTIME_VM_TIMELINE_ANALYSIS_H_
 
 #include "vm/growable_array.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 class TimelineAnalysisThread : public ZoneAllocated {
  public:
   explicit TimelineAnalysisThread(ThreadId id);
   ~TimelineAnalysisThread();
 
-  ThreadId id() const {
-    return id_;
-  }
+  ThreadId id() const { return id_; }
 
-  intptr_t NumBlocks() const {
-    return blocks_.length();
-  }
+  intptr_t NumBlocks() const { return blocks_.length(); }
 
-  TimelineEventBlock* At(intptr_t i) const {
-    return blocks_.At(i);
-  }
+  TimelineEventBlock* At(intptr_t i) const { return blocks_.At(i); }
 
  private:
   void AddBlock(TimelineEventBlock* block);
   void Finalize();
 
   const ThreadId id_;
   ZoneGrowableArray<TimelineEventBlock*> blocks_;
 
   friend class TimelineAnalysis;
 };
@@ skipping 23 matching lines @@
 // - collecting all ThreadEventBlocks by thread id.
 class TimelineAnalysis : public ValueObject {
  public:
   TimelineAnalysis(Zone* zone,
                    Isolate* isolate,
                    TimelineEventRecorder* recorder);
   ~TimelineAnalysis();
 
   void BuildThreads();
 
-  intptr_t NumThreads() const {
-    return threads_.length();
-  }
+  intptr_t NumThreads() const { return threads_.length(); }
 
-  TimelineAnalysisThread* At(intptr_t i) const {
-    return threads_[i];
-  }
+  TimelineAnalysisThread* At(intptr_t i) const { return threads_[i]; }
 
   TimelineAnalysisThread* GetThread(ThreadId tid);
 
-  bool has_error() const {
-    return has_error_;
-  }
+  bool has_error() const { return has_error_; }
 
-  const char* error_msg() const {
-    return error_msg_;
-  }
+  const char* error_msg() const { return error_msg_; }
 
  protected:
   TimelineAnalysisThread* GetOrAddThread(ThreadId tid);
 
   void DiscoverThreads();
   void FinalizeThreads();
 
   void SetError(const char* format, ...);
 
   Zone* zone_;
   Isolate* isolate_;
   TimelineEventRecorder* recorder_;
   bool has_error_;
   const char* error_msg_;
 
   ZoneGrowableArray<TimelineAnalysisThread*> threads_;
 };
 
 
 class TimelineLabelPauseInfo : public ZoneAllocated {
  public:
   explicit TimelineLabelPauseInfo(const char* name);
 
-  const char* name() const {
-    return name_;
-  }
+  const char* name() const { return name_; }
 
-  int64_t inclusive_micros() const {
-    return inclusive_micros_;
-  }
+  int64_t inclusive_micros() const { return inclusive_micros_; }
 
-  int64_t exclusive_micros() const {
-    return exclusive_micros_;
-  }
+  int64_t exclusive_micros() const { return exclusive_micros_; }
 
-  int64_t max_inclusive_micros() const {
-    return max_inclusive_micros_;
-  }
+  int64_t max_inclusive_micros() const { return max_inclusive_micros_; }
 
-  int64_t max_exclusive_micros() const {
-    return max_exclusive_micros_;
-  }
+  int64_t max_exclusive_micros() const { return max_exclusive_micros_; }
 
  private:
   // Adjusts |inclusive_micros_| and |exclusive_micros_| by |micros|.
   // Also, may adjust, max_inclusive_micros_.
   void OnPush(int64_t micros, bool already_on_stack);
 
   // Adjusts |exclusive_micros_| by |exclusive_micros|.
   // Also, may adjust |max_exclusive_micros_|.
   void OnPop(int64_t exclusive_micros);
 
@@ skipping 26 matching lines @@
   int64_t max_inclusive_micros_;
   int64_t max_exclusive_micros_;
 
   friend class TimelinePauses;
   friend class TimelinePauseTrace;
 };
 
 
 class TimelinePauses : public TimelineAnalysis {
  public:
-  TimelinePauses(Zone* zone,
-                 Isolate* isolate,
-                 TimelineEventRecorder* recorder);
+  TimelinePauses(Zone* zone, Isolate* isolate, TimelineEventRecorder* recorder);
 
   void Setup();
 
   void CalculatePauseTimesForThread(ThreadId tid);
 
   TimelineLabelPauseInfo* GetLabelPauseInfo(const char* name) const;
 
   int64_t InclusiveTime(const char* name) const;
   int64_t ExclusiveTime(const char* name) const;
   int64_t MaxInclusiveTime(const char* name) const;
   int64_t MaxExclusiveTime(const char* name) const;
 
-  intptr_t NumPauseInfos() const {
-    return labels_.length();
-  }
+  intptr_t NumPauseInfos() const { return labels_.length(); }
 
   const TimelineLabelPauseInfo* PauseInfoAt(intptr_t i) const {
     return labels_.At(i);
   }
 
  private:
   struct StackItem {
     TimelineEvent* event;
     TimelineLabelPauseInfo* pause_info;
     int64_t exclusive_micros;
@@ skipping 25 matching lines @@
   TimelineLabelPauseInfo* GetOrAddLabelPauseInfo(const char* name);
   void Aggregate(const TimelineLabelPauseInfo* thread_pause_info);
   void PrintPauseInfo(const TimelineLabelPauseInfo* pause_info);
 
   ZoneGrowableArray<TimelineLabelPauseInfo*> isolate_labels_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_ANALYSIS_H_