clang-format runtime/vm

runtime/vm/os_thread.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/os_thread.h"
 
 #include "vm/atomic.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/thread_interrupter.h"
 #include "vm/timeline.h"
 
 namespace dart {
 
 // The single thread local key which stores all the thread local data
 // for a thread.
 ThreadLocalKey OSThread::thread_key_ = kUnsetThreadLocalKey;
 OSThread* OSThread::thread_list_head_ = NULL;
 Mutex* OSThread::thread_list_lock_ = NULL;
 bool OSThread::creation_enabled_ = false;
 
 
-OSThread::OSThread() :
-    BaseThread(true),
-    id_(OSThread::GetCurrentThreadId()),
+OSThread::OSThread()
+    : BaseThread(true),
+      id_(OSThread::GetCurrentThreadId()),
 #if defined(DEBUG)
-    join_id_(kInvalidThreadJoinId),
+      join_id_(kInvalidThreadJoinId),
 #endif
 #ifndef PRODUCT
-    trace_id_(OSThread::GetCurrentThreadTraceId()),
+      trace_id_(OSThread::GetCurrentThreadTraceId()),
 #endif
-    name_(NULL),
-    timeline_block_lock_(new Mutex()),
-    timeline_block_(NULL),
-    thread_list_next_(NULL),
-    thread_interrupt_disabled_(1),  // Thread interrupts disabled by default.
-    log_(new class Log()),
-    stack_base_(0),
-    thread_(NULL) {
+      name_(NULL),
+      timeline_block_lock_(new Mutex()),
+      timeline_block_(NULL),
+      thread_list_next_(NULL),
+      thread_interrupt_disabled_(1),  // Thread interrupts disabled by default.
+      log_(new class Log()),
+      stack_base_(0),
+      thread_(NULL) {
 }
 
 
 OSThread* OSThread::CreateOSThread() {
   ASSERT(thread_list_lock_ != NULL);
   MutexLocker ml(thread_list_lock_);
   if (!creation_enabled_) {
     return NULL;
   }
   OSThread* os_thread = new OSThread();
@@ skipping 10 matching lines @@
     if (Timeline::recorder() != NULL) {
       Timeline::recorder()->FinishBlock(timeline_block_);
     }
   }
   timeline_block_ = NULL;
   delete timeline_block_lock_;
   free(name_);
 }
 
 
-
 void OSThread::SetName(const char* name) {
   MutexLocker ml(thread_list_lock_);
   // Clear the old thread name.
   if (name_ != NULL) {
     free(name_);
     name_ = NULL;
   }
   set_name(name);
 }
 
@@ skipping 47 matching lines @@
 
   // Create a new OSThread strcture and set it as the TLS.
   OSThread* os_thread = CreateOSThread();
   ASSERT(os_thread != NULL);
   OSThread::SetCurrent(os_thread);
   os_thread->set_name("Dart_Initialize");
 }
 
 
 void OSThread::Cleanup() {
-  // We cannot delete the thread local key and thread list lock,  yet.
-  // See the note on thread_list_lock_ in os_thread.h.
+// We cannot delete the thread local key and thread list lock,  yet.
+// See the note on thread_list_lock_ in os_thread.h.
 #if 0
   if (thread_list_lock_ != NULL) {
     // Delete the thread local key.
     ASSERT(thread_key_ != kUnsetThreadLocalKey);
     DeleteThreadLocal(thread_key_);
     thread_key_ = kUnsetThreadLocalKey;
 
     // Delete the global OSThread lock.
     ASSERT(thread_list_lock_ != NULL);
     delete thread_list_lock_;
@@ skipping 86 matching lines @@
     // Scan across list and remove |thread|.
     while (current != NULL) {
       if (current == thread) {
         // We found |thread|, remove from list.
         if (previous == NULL) {
           thread_list_head_ = thread->thread_list_next_;
         } else {
           previous->thread_list_next_ = current->thread_list_next_;
         }
         thread->thread_list_next_ = NULL;
-        final_thread = !creation_enabled_  && (thread_list_head_ == NULL);
+        final_thread = !creation_enabled_ && (thread_list_head_ == NULL);
         break;
       }
       previous = current;
       current = current->thread_list_next_;
     }
   }
   // Check if this is the last thread. The last thread does a cleanup
   // which removes the thread local key and the associated mutex.
   if (final_thread) {
     Cleanup();
@@ skipping 30 matching lines @@
 
 OSThread* OSThreadIterator::Next() {
   ASSERT(OSThread::thread_list_lock_ != NULL);
   ASSERT(OSThread::thread_list_lock_->IsOwnedByCurrentThread());
   OSThread* current = next_;
   next_ = next_->thread_list_next_;
   return current;
 }
 
 }  // namespace dart