clang-format runtime/vm

runtime/vm/timeline.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.
 
 #ifndef PRODUCT
 
 #include <errno.h>
 #include <fcntl.h>
 #include <cstdlib>
 
 #include "vm/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/object.h"
 #include "vm/service_event.h"
 #include "vm/thread.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, complete_timeline, false, "Record the complete timeline");
 DEFINE_FLAG(bool, startup_timeline, false, "Record the startup timeline");
 DEFINE_FLAG(bool, systrace_timeline, false, "Record the timeline to systrace");
-DEFINE_FLAG(bool, trace_timeline, false,
-            "Trace timeline backend");
-DEFINE_FLAG(bool, trace_timeline_analysis, false,
+DEFINE_FLAG(bool, trace_timeline, false, "Trace timeline backend");
+DEFINE_FLAG(bool,
+            trace_timeline_analysis,
+            false,
             "Trace timeline analysis backend");
-DEFINE_FLAG(bool, timing, false,
+DEFINE_FLAG(bool,
+            timing,
+            false,
             "Dump isolate timing information from timeline.");
-DEFINE_FLAG(charp, timeline_dir, NULL,
+DEFINE_FLAG(charp,
+            timeline_dir,
+            NULL,
             "Enable all timeline trace streams and output VM global trace "
             "into specified directory.");
-DEFINE_FLAG(charp, timeline_streams, NULL,
+DEFINE_FLAG(charp,
+            timeline_streams,
+            NULL,
             "Comma separated list of timeline streams to record. "
             "Valid values: all, API, Compiler, Dart, Debugger, Embedder, "
             "GC, Isolate, and VM.");
-DEFINE_FLAG(charp, timeline_recorder, "ring",
+DEFINE_FLAG(charp,
+            timeline_recorder,
+            "ring",
             "Select the timeline recorder used. "
             "Valid values: ring, endless, startup, and systrace.")
 
 // Implementation notes:
 //
 // Writing events:
 // |TimelineEvent|s are written into |TimelineEventBlock|s. Each |Thread| caches
 // a |TimelineEventBlock| object so that it can write events without
 // synchronizing with other threads in the system. Even though the |Thread| owns
 // the |TimelineEventBlock| the block may need to be reclaimed by the reporting
@@ skipping 107 matching lines @@
   }
   for (intptr_t i = 0; i < streams->length(); i++) {
     free((*streams)[i]);
   }
   delete streams;
 }
 
 
 // Returns true if |streams| contains |stream| or "all". Not case sensitive.
 static bool HasStream(MallocGrowableArray<char*>* streams, const char* stream) {
-  if ((FLAG_timeline_dir != NULL) ||
-      FLAG_timing || FLAG_complete_timeline || FLAG_startup_timeline) {
+  if ((FLAG_timeline_dir != NULL) || FLAG_timing || FLAG_complete_timeline ||
+      FLAG_startup_timeline) {
     return true;
   }
   for (intptr_t i = 0; i < streams->length(); i++) {
     const char* checked_stream = (*streams)[i];
     if ((strstr(checked_stream, "all") != NULL) ||
         (strstr(checked_stream, stream) != NULL)) {
       return true;
     }
   }
   return false;
 }
 
 
 void Timeline::InitOnce() {
   ASSERT(recorder_ == NULL);
   recorder_ = CreateTimelineRecorder();
   ASSERT(recorder_ != NULL);
   enabled_streams_ = GetEnabledByDefaultTimelineStreams();
-  // Global overrides.
+// Global overrides.
 #define TIMELINE_STREAM_FLAG_DEFAULT(name, not_used)                           \
-  stream_##name##_.Init(#name,                                                 \
-                        HasStream(enabled_streams_, #name));
+  stream_##name##_.Init(#name, HasStream(enabled_streams_, #name));
   TIMELINE_STREAM_LIST(TIMELINE_STREAM_FLAG_DEFAULT)
 #undef TIMELINE_STREAM_FLAG_DEFAULT
 
   if (Timeline::stream_Embedder_.enabled() &&
       (Timeline::get_start_recording_cb() != NULL)) {
     Timeline::get_start_recording_cb()();
   }
 }
 
 
@@ skipping 18 matching lines @@
 
   if (Timeline::stream_Embedder_.enabled() &&
       (Timeline::get_stop_recording_cb() != NULL)) {
     Timeline::get_stop_recording_cb()();
   }
 
   if (FLAG_timeline_dir != NULL) {
     recorder_->WriteTo(FLAG_timeline_dir);
   }
 
-  // Disable global streams.
+// Disable global streams.
 #define TIMELINE_STREAM_DISABLE(name, not_used)                                \
   Timeline::stream_##name##_.set_enabled(false);
   TIMELINE_STREAM_LIST(TIMELINE_STREAM_DISABLE)
 #undef TIMELINE_STREAM_DISABLE
   delete recorder_;
   recorder_ = NULL;
   if (enabled_streams_ != NULL) {
     FreeEnabledByDefaultTimelineStreams(enabled_streams_);
     enabled_streams_ = NULL;
   }
@@ skipping 31 matching lines @@
   JSONObject obj(js);
   obj.AddProperty("type", "TimelineFlags");
   TimelineEventRecorder* recorder = Timeline::recorder();
   if (recorder == NULL) {
     obj.AddProperty("recorderName", "null");
   } else {
     obj.AddProperty("recorderName", recorder->name());
   }
   {
     JSONArray availableStreams(&obj, "availableStreams");
-#define ADD_STREAM_NAME(name, not_used)                                        \
-    availableStreams.AddValue(#name);
-TIMELINE_STREAM_LIST(ADD_STREAM_NAME);
+#define ADD_STREAM_NAME(name, not_used) availableStreams.AddValue(#name);
+    TIMELINE_STREAM_LIST(ADD_STREAM_NAME);
 #undef ADD_STREAM_NAME
   }
   {
     JSONArray recordedStreams(&obj, "recordedStreams");
 #define ADD_RECORDED_STREAM_NAME(name, not_used)                               \
-    if (stream_##name##_.enabled()) {                                          \
-      recordedStreams.AddValue(#name);                                         \
-    }
-TIMELINE_STREAM_LIST(ADD_RECORDED_STREAM_NAME);
+  if (stream_##name##_.enabled()) {                                            \
+    recordedStreams.AddValue(#name);                                           \
+  }
+    TIMELINE_STREAM_LIST(ADD_RECORDED_STREAM_NAME);
 #undef ADD_RECORDED_STREAM_NAME
   }
 }
 
 
 void Timeline::Clear() {
   TimelineEventRecorder* recorder = Timeline::recorder();
   if (recorder == NULL) {
     return;
   }
   ReclaimCachedBlocksFromThreads();
   recorder->Clear();
 }
 
 
 TimelineEventRecorder* Timeline::recorder_ = NULL;
 MallocGrowableArray<char*>* Timeline::enabled_streams_ = NULL;
 Dart_EmbedderTimelineStartRecording Timeline::start_recording_cb_ = NULL;
 Dart_EmbedderTimelineStopRecording Timeline::stop_recording_cb_ = NULL;
 
 #define TIMELINE_STREAM_DEFINE(name, enabled_by_default)                       \
   TimelineStream Timeline::stream_##name##_;
-  TIMELINE_STREAM_LIST(TIMELINE_STREAM_DEFINE)
+TIMELINE_STREAM_LIST(TIMELINE_STREAM_DEFINE)
 #undef TIMELINE_STREAM_DEFINE
 
 TimelineEvent::TimelineEvent()
     : timestamp0_(0),
       timestamp1_(0),
       thread_timestamp0_(-1),
       thread_timestamp1_(-1),
       arguments_(NULL),
       arguments_length_(0),
       state_(0),
       label_(NULL),
       category_(""),
       thread_(OSThread::kInvalidThreadId),
-      isolate_id_(ILLEGAL_PORT) {
-}
+      isolate_id_(ILLEGAL_PORT) {}
 
 
 TimelineEvent::~TimelineEvent() {
   Reset();
 }
 
 
 void TimelineEvent::Reset() {
   if (owns_label() && label_ != NULL) {
     free(const_cast<char*>(label_));
@@ skipping 42 matching lines @@
 
 void TimelineEvent::DurationBegin(const char* label,
                                   int64_t micros,
                                   int64_t thread_micros) {
   Init(kDuration, label);
   set_timestamp0(micros);
   set_thread_timestamp0(thread_micros);
 }
 
 
-void TimelineEvent::DurationEnd(int64_t micros,
-                                int64_t thread_micros) {
+void TimelineEvent::DurationEnd(int64_t micros, int64_t thread_micros) {
   ASSERT(timestamp1_ == 0);
   set_timestamp1(micros);
   set_thread_timestamp1(thread_micros);
 }
 
 
-void TimelineEvent::Instant(const char* label,
-                            int64_t micros) {
+void TimelineEvent::Instant(const char* label, int64_t micros) {
   Init(kInstant, label);
   set_timestamp0(micros);
 }
 
 
 void TimelineEvent::Duration(const char* label,
                              int64_t start_micros,
                              int64_t end_micros,
                              int64_t thread_start_micros,
                              int64_t thread_end_micros) {
@@ skipping 57 matching lines @@
 
 
 void TimelineEvent::SetArgument(intptr_t i, const char* name, char* argument) {
   ASSERT(i >= 0);
   ASSERT(i < arguments_length_);
   arguments_[i].name = name;
   arguments_[i].value = argument;
 }
 
 
-void TimelineEvent::FormatArgument(intptr_t i, const char* name,
-                                   const char* fmt, ...) {
+void TimelineEvent::FormatArgument(intptr_t i,
+                                   const char* name,
+                                   const char* fmt,
+                                   ...) {
   ASSERT(i >= 0);
   ASSERT(i < arguments_length_);
   va_list args;
   va_start(args, fmt);
   intptr_t len = OS::VSNPrint(NULL, 0, fmt, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(malloc(len + 1));
   va_list args2;
   va_start(args2, fmt);
@@ skipping 20 matching lines @@
 
 intptr_t TimelineEvent::PrintSystrace(char* buffer, intptr_t buffer_size) {
   ASSERT(buffer != NULL);
   ASSERT(buffer_size > 0);
   buffer[0] = '\0';
   intptr_t length = 0;
   int64_t pid = OS::ProcessId();
   switch (event_type()) {
     case kBegin: {
       length = OS::SNPrint(buffer, buffer_size, "B|%" Pd64 "|%s", pid, label());
-    }
-    break;
+    } break;
     case kEnd: {
       length = OS::SNPrint(buffer, buffer_size, "E");
-    }
-    break;
+    } break;
     case kCounter: {
       if (arguments_length_ > 0) {
         // We only report the first counter value.
-        length = OS::SNPrint(buffer, buffer_size,
-                             "C|%" Pd64 "|%s|%s",
-                             pid,
-                             label(),
-                             arguments_[0].value);
+        length = OS::SNPrint(buffer, buffer_size, "C|%" Pd64 "|%s|%s", pid,
+                             label(), arguments_[0].value);
       }
     }
     default:
       // Ignore event types that we cannot serialize to the Systrace format.
-    break;
+      break;
   }
   return length;
 }
 
 
 void TimelineEvent::Complete() {
   TimelineEventRecorder* recorder = Timeline::recorder();
   if (recorder != NULL) {
     recorder->CompleteEvent(this);
   }
@@ skipping 15 matching lines @@
 
 void TimelineEvent::StreamInit(TimelineStream* stream) {
   if (stream != NULL) {
     category_ = stream->name();
   } else {
     category_ = "";
   }
 }
 
 
-void TimelineEvent::Init(EventType event_type,
-                         const char* label) {
+void TimelineEvent::Init(EventType event_type, const char* label) {
   ASSERT(label != NULL);
   state_ = 0;
   timestamp0_ = 0;
   timestamp1_ = 0;
   thread_timestamp0_ = -1;
   thread_timestamp1_ = -1;
   OSThread* os_thread = OSThread::Current();
   ASSERT(os_thread != NULL);
   thread_ = os_thread->trace_id();
   Isolate* isolate = Isolate::Current();
   if (isolate != NULL) {
     isolate_id_ = isolate->main_port();
   } else {
     isolate_id_ = ILLEGAL_PORT;
   }
   label_ = label;
   FreeArguments();
   set_pre_serialized_json(false);
   set_event_type(event_type);
   set_owns_label(false);
 }
 
 
 bool TimelineEvent::Within(int64_t time_origin_micros,
                            int64_t time_extent_micros) {
-  if ((time_origin_micros == -1) ||
-      (time_extent_micros == -1)) {
+  if ((time_origin_micros == -1) || (time_extent_micros == -1)) {
     // No time range specified.
     return true;
   }
   if (IsFinishedDuration()) {
     // Event is from e_t0 to e_t1.
     int64_t e_t0 = TimeOrigin();
     int64_t e_t1 = TimeEnd();
     ASSERT(e_t0 <= e_t1);
     // Range is from r_t0 to r_t1.
     int64_t r_t0 = time_origin_micros;
@@ skipping 31 matching lines @@
   obj.AddProperty("cat", category_);
   obj.AddProperty64("tid", tid);
   obj.AddProperty64("pid", pid);
   obj.AddPropertyTimeMicros("ts", TimeOrigin());
   if (HasThreadCPUTime()) {
     obj.AddPropertyTimeMicros("tts", ThreadCPUTimeOrigin());
   }
   switch (event_type()) {
     case kBegin: {
       obj.AddProperty("ph", "B");
-    }
-    break;
+    } break;
     case kEnd: {
       obj.AddProperty("ph", "E");
-    }
-    break;
+    } break;
     case kDuration: {
       obj.AddProperty("ph", "X");
       obj.AddPropertyTimeMicros("dur", TimeDuration());
       if (HasThreadCPUTime()) {
         obj.AddPropertyTimeMicros("tdur", ThreadCPUTimeDuration());
       }
-    }
-    break;
+    } break;
     case kInstant: {
       obj.AddProperty("ph", "i");
       obj.AddProperty("s", "p");
-    }
-    break;
+    } break;
     case kAsyncBegin: {
       obj.AddProperty("ph", "b");
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
-    }
-    break;
+    } break;
     case kAsyncInstant: {
       obj.AddProperty("ph", "n");
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
-    }
-    break;
+    } break;
     case kAsyncEnd: {
       obj.AddProperty("ph", "e");
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
-    }
-    break;
+    } break;
     case kMetadata: {
       obj.AddProperty("ph", "M");
-    }
-    break;
+    } break;
     case kCounter: {
       obj.AddProperty("ph", "C");
-    }
-    break;
+    } break;
     default:
       UNIMPLEMENTED();
   }
   {
     JSONObject args(&obj, "args");
     for (intptr_t i = 0; i < arguments_length_; i++) {
       const TimelineEventArgument& arg = arguments_[i];
       args.AddProperty(arg.name, arg.value);
     }
     if (isolate_id_ != ILLEGAL_PORT) {
@@ skipping 36 matching lines @@
   }
   return timestamp1_ - timestamp0_;
 }
 
 
 bool TimelineEvent::HasThreadCPUTime() const {
   return (thread_timestamp0_ != -1);
 }
 
 
-
 int64_t TimelineEvent::ThreadCPUTimeOrigin() const {
   ASSERT(HasThreadCPUTime());
   return thread_timestamp0_;
 }
 
 
 int64_t TimelineEvent::ThreadCPUTimeDuration() const {
   ASSERT(HasThreadCPUTime());
   if (thread_timestamp1_ == -1) {
     // This duration is still open, use current time as end.
     return OS::GetCurrentThreadCPUMicros() - thread_timestamp0_;
   }
   return thread_timestamp1_ - thread_timestamp0_;
 }
 
 
-TimelineStream::TimelineStream()
-    : name_(NULL),
-      enabled_(false) {
-}
+TimelineStream::TimelineStream() : name_(NULL), enabled_(false) {}
 
 
-void TimelineStream::Init(const char* name,
-                          bool enabled) {
+void TimelineStream::Init(const char* name, bool enabled) {
   name_ = name;
   enabled_ = enabled;
 }
 
 
 TimelineEvent* TimelineStream::StartEvent() {
   TimelineEventRecorder* recorder = Timeline::recorder();
   if (!enabled() || (recorder == NULL)) {
     return NULL;
   }
@@ skipping 83 matching lines @@
                                       const char* argument) {
   if (!enabled()) {
     return;
   }
   SetArgument(i, name, strdup(argument));
 }
 
 
 void TimelineEventScope::FormatArgument(intptr_t i,
                                         const char* name,
-                                        const char* fmt, ...) {
+                                        const char* fmt,
+                                        ...) {
   if (!enabled()) {
     return;
   }
   va_list args;
   va_start(args, fmt);
   intptr_t len = OS::VSNPrint(NULL, 0, fmt, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(malloc(len + 1));
   va_list args2;
@@ skipping 58 matching lines @@
   if (!ShouldEmitEvent()) {
     return;
   }
   TimelineEvent* event = stream()->StartEvent();
   if (event == NULL) {
     // Stream is now disabled.
     return;
   }
   ASSERT(event != NULL);
   // Emit a duration event.
-  event->Duration(label(),
-                  timestamp_,
-                  OS::GetCurrentMonotonicMicros(),
-                  thread_timestamp_,
-                  OS::GetCurrentThreadCPUMicros());
+  event->Duration(label(), timestamp_, OS::GetCurrentMonotonicMicros(),
+                  thread_timestamp_, OS::GetCurrentThreadCPUMicros());
   StealArguments(event);
   event->Complete();
 }
 
 
 TimelineBeginEndScope::TimelineBeginEndScope(TimelineStream* stream,
                                              const char* label)
     : TimelineEventScope(stream, label) {
   if (!FLAG_support_timeline) {
     return;
@@ skipping 64 matching lines @@
 
 TimelineEventFilter::TimelineEventFilter(int64_t time_origin_micros,
                                          int64_t time_extent_micros)
     : time_origin_micros_(time_origin_micros),
       time_extent_micros_(time_extent_micros) {
   ASSERT(time_origin_micros_ >= -1);
   ASSERT(time_extent_micros_ >= -1);
 }
 
 
-TimelineEventFilter::~TimelineEventFilter() {
-}
+TimelineEventFilter::~TimelineEventFilter() {}
 
 
 IsolateTimelineEventFilter::IsolateTimelineEventFilter(
     Dart_Port isolate_id,
     int64_t time_origin_micros,
     int64_t time_extent_micros)
-    : TimelineEventFilter(time_origin_micros,
-                          time_extent_micros),
-      isolate_id_(isolate_id) {
-}
+    : TimelineEventFilter(time_origin_micros, time_extent_micros),
+      isolate_id_(isolate_id) {}
 
 
 TimelineEventRecorder::TimelineEventRecorder()
-    : async_id_(0),
-      time_low_micros_(0),
-      time_high_micros_(0) {
-}
+    : async_id_(0), time_low_micros_(0), time_high_micros_(0) {}
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
   if (!FLAG_support_service) {
     return;
   }
   OSThreadIterator it;
   while (it.HasNext()) {
     OSThread* thread = it.Next();
     const char* thread_name = thread->name();
@@ skipping 47 matching lines @@
     // Thread has no block. Attempt to allocate one.
     thread_block = GetNewBlockLocked();
     thread->set_timeline_block(thread_block);
   }
   if (thread_block != NULL) {
     // NOTE: We are exiting this function with the thread's block lock held.
     ASSERT(!thread_block->IsFull());
     TimelineEvent* event = thread_block->StartEvent();
     return event;
   }
-  // Drop lock here as no event is being handed out.
+// Drop lock here as no event is being handed out.
 #if defined(DEBUG)
   if (T != NULL) {
     T->DecrementNoSafepointScopeDepth();
   }
 #endif  // defined(DEBUG)
   thread_block_lock->Unlock();
   return NULL;
 }
 
 
@@ skipping 56 matching lines @@
   Dart_FileOpenCallback file_open = Dart::file_open_callback();
   Dart_FileWriteCallback file_write = Dart::file_write_callback();
   Dart_FileCloseCallback file_close = Dart::file_close_callback();
   if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
     return;
   }
 
   Timeline::ReclaimCachedBlocksFromThreads();
 
   intptr_t pid = OS::ProcessId();
-  char* filename = OS::SCreate(NULL,
-      "%s/dart-timeline-%" Pd ".json", directory, pid);
+  char* filename =
+      OS::SCreate(NULL, "%s/dart-timeline-%" Pd ".json", directory, pid);
   void* file = (*file_open)(filename, true);
   if (file == NULL) {
     OS::Print("Failed to write timeline file: %s\n", filename);
     free(filename);
     return;
   }
   free(filename);
 
   JSONStream js;
   TimelineEventFilter filter;
   PrintTraceEvent(&js, &filter);
   // Steal output from JSONStream.
   char* output = NULL;
   intptr_t output_length = 0;
   js.Steal(&output, &output_length);
   (*file_write)(output, output_length, file);
   // Free the stolen output.
   free(output);
   (*file_close)(file);
 
   return;
 }
 
 
 int64_t TimelineEventRecorder::GetNextAsyncId() {
   // TODO(johnmccutchan): Gracefully handle wrap around.
-  uint32_t next = static_cast<uint32_t>(
-      AtomicOperations::FetchAndIncrement(&async_id_));
+  uint32_t next =
+      static_cast<uint32_t>(AtomicOperations::FetchAndIncrement(&async_id_));
   return static_cast<int64_t>(next);
 }
 
 
 void TimelineEventRecorder::FinishBlock(TimelineEventBlock* block) {
   if (block == NULL) {
     return;
   }
   MutexLocker ml(&lock_);
   block->Finish();
 }
 
 
 TimelineEventBlock* TimelineEventRecorder::GetNewBlock() {
   MutexLocker ml(&lock_);
   return GetNewBlockLocked();
 }
 
 
 TimelineEventFixedBufferRecorder::TimelineEventFixedBufferRecorder(
     intptr_t capacity)
-    : blocks_(NULL),
-      capacity_(capacity),
-      num_blocks_(0),
-      block_cursor_(0) {
+    : blocks_(NULL), capacity_(capacity), num_blocks_(0), block_cursor_(0) {
   // Capacity must be a multiple of TimelineEventBlock::kBlockSize
   ASSERT((capacity % TimelineEventBlock::kBlockSize) == 0);
   // Allocate blocks array.
   num_blocks_ = capacity / TimelineEventBlock::kBlockSize;
-  blocks_ =
-      reinterpret_cast<TimelineEventBlock**>(
-          calloc(num_blocks_, sizeof(TimelineEventBlock*)));
+  blocks_ = reinterpret_cast<TimelineEventBlock**>(
+      calloc(num_blocks_, sizeof(TimelineEventBlock*)));
   // Allocate each block.
   for (intptr_t i = 0; i < num_blocks_; i++) {
     blocks_[i] = new TimelineEventBlock(i);
   }
   // Chain blocks together.
   for (intptr_t i = 0; i < num_blocks_ - 1; i++) {
     blocks_[i]->set_next(blocks_[i + 1]);
   }
 }
 
@@ skipping 109 matching lines @@
 
 void TimelineEventFixedBufferRecorder::CompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   ThreadBlockCompleteEvent(event);
 }
 
 
 TimelineEventSystraceRecorder::TimelineEventSystraceRecorder(intptr_t capacity)
-    : TimelineEventFixedBufferRecorder(capacity),
-      systrace_fd_(-1) {
+    : TimelineEventFixedBufferRecorder(capacity), systrace_fd_(-1) {
 #if defined(TARGET_OS_ANDROID) || defined(TARGET_OS_LINUX)
   const char* kSystracePath = "/sys/kernel/debug/tracing/trace_marker";
   systrace_fd_ = open(kSystracePath, O_WRONLY);
   if ((systrace_fd_ < 0) && FLAG_trace_timeline) {
     OS::PrintErr("TimelineEventSystraceRecorder: Could not open `%s`\n",
                  kSystracePath);
   }
 #else
-  OS::PrintErr("Warning: The systrace timeline recorder is equivalent to the"
-               "ring recorder on this platform.");
+  OS::PrintErr(
+      "Warning: The systrace timeline recorder is equivalent to the"
+      "ring recorder on this platform.");
 #endif
 }
 
 
 TimelineEventSystraceRecorder::~TimelineEventSystraceRecorder() {
 #if defined(TARGET_OS_ANDROID) || defined(TARGET_OS_LINUX)
   if (systrace_fd_ >= 0) {
     close(systrace_fd_);
   }
 #endif
@@ skipping 54 matching lines @@
   if (block_cursor_ == num_blocks_) {
     return NULL;
   }
   TimelineEventBlock* block = blocks_[block_cursor_++];
   block->Reset();
   block->Open();
   return block;
 }
 
 
-TimelineEventCallbackRecorder::TimelineEventCallbackRecorder() {
-}
+TimelineEventCallbackRecorder::TimelineEventCallbackRecorder() {}
 
 
-TimelineEventCallbackRecorder::~TimelineEventCallbackRecorder() {
-}
+TimelineEventCallbackRecorder::~TimelineEventCallbackRecorder() {}
 
 
 void TimelineEventCallbackRecorder::PrintJSON(JSONStream* js,
-                                               TimelineEventFilter* filter) {
+                                              TimelineEventFilter* filter) {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
   }
 }
@@ skipping 15 matching lines @@
 }
 
 
 void TimelineEventCallbackRecorder::CompleteEvent(TimelineEvent* event) {
   OnEvent(event);
   delete event;
 }
 
 
 TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
-    : head_(NULL),
-      block_index_(0) {
-}
+    : head_(NULL), block_index_(0) {}
 
 
 void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js,
                                              TimelineEventFilter* filter) {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
@@ skipping 107 matching lines @@
   OSThread* thread = OSThread::Current();
   thread->set_timeline_block(NULL);
 }
 
 
 TimelineEventBlock::TimelineEventBlock(intptr_t block_index)
     : next_(NULL),
       length_(0),
       block_index_(block_index),
       thread_id_(OSThread::kInvalidThreadId),
-      in_use_(false) {
-}
+      in_use_(false) {}
 
 
 TimelineEventBlock::~TimelineEventBlock() {
   Reset();
 }
 
 
 void TimelineEventBlock::PrintJSON(JSONStream* js) const {
   ASSERT(!in_use());
   JSONArray events(js);
@@ skipping 76 matching lines @@
   if (Service::timeline_stream.enabled()) {
     ServiceEvent service_event(NULL, ServiceEvent::kTimelineEvents);
     service_event.set_timeline_event_block(this);
     Service::HandleEvent(&service_event);
   }
 }
 
 
 TimelineEventBlockIterator::TimelineEventBlockIterator(
     TimelineEventRecorder* recorder)
-    : current_(NULL),
-      recorder_(NULL) {
+    : current_(NULL), recorder_(NULL) {
   Reset(recorder);
 }
 
 
 TimelineEventBlockIterator::~TimelineEventBlockIterator() {
   Reset(NULL);
 }
 
 
 void TimelineEventBlockIterator::Reset(TimelineEventRecorder* recorder) {
@@ skipping 22 matching lines @@
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart
 
 #endif  // !PRODUCT