clang-format runtime/vm

runtime/vm/os_thread.h

 // Copyright (c) 2012, 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_OS_THREAD_H_
 #define RUNTIME_VM_OS_THREAD_H_
 
 #include "platform/globals.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
@@ skipping 52 matching lines @@
     return id_;
   }
 
 #ifndef PRODUCT
   ThreadId trace_id() const {
     ASSERT(trace_id_ != OSThread::kInvalidThreadId);
     return trace_id_;
   }
 #endif
 
-  const char* name() const {
-    return name_;
-  }
+  const char* name() const { return name_; }
 
   void SetName(const char* name);
 
   void set_name(const char* name) {
     ASSERT(OSThread::Current() == this);
     ASSERT(name_ == NULL);
     ASSERT(name != NULL);
     name_ = strdup(name);
   }
 
-  Mutex* timeline_block_lock() const {
-    return timeline_block_lock_;
-  }
+  Mutex* timeline_block_lock() const { return timeline_block_lock_; }
 
   // Only safe to access when holding |timeline_block_lock_|.
-  TimelineEventBlock* timeline_block() const {
-    return timeline_block_;
-  }
+  TimelineEventBlock* timeline_block() const { return timeline_block_; }
 
   // Only safe to access when holding |timeline_block_lock_|.
   void set_timeline_block(TimelineEventBlock* block) {
     timeline_block_ = block;
   }
 
   Log* log() const { return log_; }
 
   uword stack_base() const { return stack_base_; }
   void set_stack_base(uword stack_base) { stack_base_ = stack_base; }
@@ skipping 36 matching lines @@
   // TODO(5411455): Use flag to override default value and Validate the
   // stack size by querying OS.
   static uword GetSpecifiedStackSize() {
     ASSERT(OSThread::kStackSizeBuffer < OSThread::GetMaxStackSize());
     uword stack_size = OSThread::GetMaxStackSize() - OSThread::kStackSizeBuffer;
     return stack_size;
   }
   static BaseThread* GetCurrentTLS() {
     return reinterpret_cast<BaseThread*>(OSThread::GetThreadLocal(thread_key_));
   }
-  static void SetCurrentTLS(uword value) {
-    SetThreadLocal(thread_key_, value);
-  }
+  static void SetCurrentTLS(uword value) { SetThreadLocal(thread_key_, value); }
 
-  typedef void (*ThreadStartFunction) (uword parameter);
-  typedef void (*ThreadDestructor) (void* parameter);
+  typedef void (*ThreadStartFunction)(uword parameter);
+  typedef void (*ThreadDestructor)(void* parameter);
 
   // Start a thread running the specified function. Returns 0 if the
   // thread started successfuly and a system specific error code if
   // the thread failed to start.
-  static int Start(
-      const char* name, ThreadStartFunction function, uword parameter);
+  static int Start(const char* name,
+                   ThreadStartFunction function,
+                   uword parameter);
 
   static ThreadLocalKey CreateThreadLocal(ThreadDestructor destructor = NULL);
   static void DeleteThreadLocal(ThreadLocalKey key);
   static uword GetThreadLocal(ThreadLocalKey key) {
     return ThreadInlineImpl::GetThreadLocal(key);
   }
   static ThreadId GetCurrentThreadId();
   static void SetThreadLocal(ThreadLocalKey key, uword value);
   static intptr_t GetMaxStackSize();
   static void Join(ThreadJoinId id);
@@ skipping 23 matching lines @@
   // to create a new OSThread structure.
   OSThread();
 
   // These methods should not be used in a generic way and hence
   // are private, they have been added to solve the problem of
   // accessing the VM thread structure from an OSThread object
   // in the windows thread interrupter which is used for profiling.
   // We could eliminate this requirement if the windows thread interrupter
   // is implemented differently.
   Thread* thread() const { return thread_; }
-  void set_thread(Thread* value) {
-    thread_ = value;
-  }
+  void set_thread(Thread* value) { thread_ = value; }
 
   static void Cleanup();
 #ifndef PRODUCT
   static ThreadId GetCurrentThreadTraceId();
 #endif  // PRODUCT
   static OSThread* GetOSThreadFromThread(Thread* thread);
   static void AddThreadToListLocked(OSThread* thread);
   static void RemoveThreadFromList(OSThread* thread);
   static OSThread* CreateAndSetUnknownThread();
 
@@ skipping 86 matching lines @@
   friend class TimelineEventBlockIterator;
   friend class TimelineEventRecorder;
   friend class PageSpace;
   friend void Dart_TestMutex();
   DISALLOW_COPY_AND_ASSIGN(Mutex);
 };
 
 
 class Monitor {
  public:
-  enum WaitResult {
-    kNotified,
-    kTimedOut
-  };
+  enum WaitResult { kNotified, kTimedOut };
 
   static const int64_t kNoTimeout = 0;
 
   Monitor();
   ~Monitor();
 
 #if defined(DEBUG)
   bool IsOwnedByCurrentThread() const {
     return owner_ == OSThread::GetCurrentThreadId();
   }
@@ skipping 26 matching lines @@
   friend class SafepointMonitorLocker;
   friend void Dart_TestMonitor();
   DISALLOW_COPY_AND_ASSIGN(Monitor);
 };
 
 
 }  // namespace dart
 
 
 #endif  // RUNTIME_VM_OS_THREAD_H_