base/threading: restrict to set only current thread priority

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 71 matching lines @@
       : handle_(handle),
         id_(0) {
   }
 
   PlatformThreadHandle(Handle handle,
                        PlatformThreadId id)
       : handle_(handle),
         id_(id) {
   }
 
+  // TODO(toyoshim): Remove id() and use PlatformThread::CurrentId() instead.
+  // See http://crbug.com/468793 for related changes.
   PlatformThreadId id() const {
     return id_;
   }
 
   bool is_equal(const PlatformThreadHandle& other) const {
     return handle_ == other.handle_;
   }
 
   bool is_null() const {
     return !handle_;
   }
 
   Handle platform_handle() const {
     return handle_;
   }
 
  private:
   Handle handle_;
   PlatformThreadId id_;
 };
 
 const PlatformThreadId kInvalidThreadId(0);
 
-// Valid values for SetThreadPriority(), listed in increasing order of
-// importance.
+// Valid values for priority of Thread::Options and SimpleThread::Options, and
+// SetCurrentThreadPriority(), listed in increasing order of importance.
 enum class ThreadPriority {
   // Suitable for threads that shouldn't disrupt high priority work.
   BACKGROUND,
   // Default priority level.
   NORMAL,
   // Suitable for threads which generate data for the display (at ~60Hz).
   DISPLAY,
   // Suitable for low-latency, glitch-resistant audio.
   REALTIME_AUDIO,
 };
@@ skipping 42 matching lines @@
   // |*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().
+  // the thread is set based on |priority|.
   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);
 
-  // Toggles the target thread's priority at runtime.  Prefer
-  // CreateWithPriority() to set the thread's initial priority.
-  // NOTE: The call may fail if the caller thread is not the same as the
-  // target thread on POSIX.  For example, seccomp-bpf blocks it by default
-  // in the sandbox.
-  static void SetThreadPriority(PlatformThreadHandle handle,
-                                ThreadPriority priority);
+  // Toggles the current thread's priority at runtime. A thread may not be able
+  // to raise its priority back up after lowering it if the process does not
+  // have a proper permission, e.g. CAP_SYS_NICE on Linux.
+  // Since changing other threads' priority is not permitted in favor of
+  // security, this interface is restricted to change only the current thread
+  // priority (https://crbug.com/399473).
+  static void SetCurrentThreadPriority(ThreadPriority priority);
 
-  static ThreadPriority GetThreadPriority(PlatformThreadHandle handle);
+  static ThreadPriority GetCurrentThreadPriority();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PlatformThread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_PLATFORM_THREAD_H_