Add full SetThreadPriority support to Windows.

base/threading/platform_thread.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // WARNING: You should *NOT* be using this class directly.  PlatformThread is
 // the low-level platform-specific abstraction to the OS's threading interface.
 // You should instead be using a message-loop driven Thread, see thread.h.
 
 #ifndef BASE_THREADING_PLATFORM_THREAD_H_
 #define BASE_THREADING_PLATFORM_THREAD_H_
@@ skipping 93 matching lines @@
  private:
   friend class PlatformThread;
 
   Handle handle_;
   PlatformThreadId id_;
 };
 
 const PlatformThreadId kInvalidThreadId(0);
 
 // Valid values for SetThreadPriority()
-enum ThreadPriority{
+enum ThreadPriority {
   kThreadPriority_Normal,

[rvargas (doing something else), 2015/03/19 22:19:21]

Let's order this according to priority.

[gab, 2015/03/30 20:14:45]

I was thinking about that too, but I was thinking we should probably also make
this an "enum class" (since we toggle it back-and-forth with the OS priority
expressed as an integer and can easily mix the two otherwise) -- feels like this
belongs in a follow-up (or precursor CL), WDYT?

[rvargas (doing something else), 2015/03/30 22:31:22]

I doesn't have to be part of this CL, but we need a clear priority order here.

   // Suitable for low-latency, glitch-resistant audio.
   kThreadPriority_RealtimeAudio,
   // Suitable for threads which generate data for the display (at ~60Hz).
   kThreadPriority_Display,
-  // Suitable for threads that shouldn't disrupt high priority work.
+  // Suitable for threads that shouldn't disrupt high priority work. Extra
+  // background properties (low IO/memory priority) can be achieved on some
+  // platforms if this mode is set from the current thread.

[rvargas (doing something else), 2015/03/19 22:19:21]

nit: "if this mode"? Do you mean this priority?

[gab, 2015/03/30 20:14:45]

Done.

   kThreadPriority_Background
 };
 
 // A namespace for low-level thread functions.
 class BASE_EXPORT PlatformThread {
  public:
   // Implement this interface to run code on a background thread.  Your
   // ThreadMain method will be called on the newly created thread.
   class BASE_EXPORT Delegate {
    public:
     virtual void ThreadMain() = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
   // Gets the current thread id, which may be useful for logging purposes.
   static PlatformThreadId CurrentId();
 
   // Gets the current thread reference, which can be used to check if
   // we're on the right thread quickly.
   static PlatformThreadRef CurrentRef();
 
-  // Get the current handle.
+  // Get the handle representing the current thread. On some platforms, this can
+  // be a pseudo handle constant which will always represent the thread using it
+  // and hence should not be shared with other threads nor be used to
+  // differentiate the current thread from another.
   static PlatformThreadHandle CurrentHandle();
 
   // Yield the current thread so another thread can be scheduled.
   static void YieldCurrentThread();
 
   // Sleeps for the specified duration.
   static void Sleep(base::TimeDelta duration);
 
   // Sets the thread name visible to debuggers/tools. This has no effect
   // otherwise. This name pointer is not copied internally. Thus, it must stay
   // valid until the thread ends.
   static void SetName(const char* name);
 
   // Gets the thread name, if previously set by SetName.
   static const char* GetName();
 
   // Creates a new thread.  The |stack_size| parameter can be 0 to indicate
   // that the default stack size should be used.  Upon success,
   // |*thread_handle| will be assigned a handle to the newly created thread,
   // and |delegate|'s ThreadMain method will be executed on the newly created
   // thread.
   // NOTE: When you are done with the thread handle, you must call Join to
   // release system resources associated with the thread.  You must ensure that
   // the Delegate object outlives the thread.
   static bool Create(size_t stack_size, Delegate* delegate,
                      PlatformThreadHandle* thread_handle);
 
   // CreateWithPriority() does the same thing as Create() except the priority of
   // the thread is set based on |priority|.  Can be used in place of Create()
-  // followed by SetThreadPriority().  SetThreadPriority() has not been
-  // implemented on the Linux platform yet, this is the only way to get a high
-  // priority thread on Linux.
+  // followed by SetThreadPriority().
   static bool CreateWithPriority(size_t stack_size, Delegate* delegate,
                                  PlatformThreadHandle* thread_handle,
                                  ThreadPriority priority);
 
   // CreateNonJoinable() does the same thing as Create() except the thread
   // cannot be Join()'d.  Therefore, it also does not output a
   // PlatformThreadHandle.
   static bool CreateNonJoinable(size_t stack_size, Delegate* delegate);
 
   // Joins with a thread created via the Create function.  This function blocks
   // the caller until the designated thread exits.  This will invalidate
   // |thread_handle|.
   static void Join(PlatformThreadHandle thread_handle);
 
   static void SetThreadPriority(PlatformThreadHandle handle,
                                 ThreadPriority priority);
 
+  static ThreadPriority GetThreadPriority(PlatformThreadHandle handle);
+
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PlatformThread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_PLATFORM_THREAD_H_