Inline ConvertToSystemPriority.

webrtc/base/platform_thread.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 82 matching lines @@
 void CALLBACK RaiseFlag(ULONG_PTR param) {
   *reinterpret_cast<bool*>(param) = true;
 }
 #else
 struct ThreadAttributes {
   ThreadAttributes() { pthread_attr_init(&attr); }
   ~ThreadAttributes() { pthread_attr_destroy(&attr); }
   pthread_attr_t* operator&() { return &attr; }
   pthread_attr_t attr;
 };
-
-int ConvertToSystemPriority(ThreadPriority priority,
-                            int min_prio,
-                            int max_prio) {
-  RTC_DCHECK(max_prio - min_prio > 2);
-  const int top_prio = max_prio - 1;
-  const int low_prio = min_prio + 1;
-
-  switch (priority) {
-    case kLowPriority:
-      return low_prio;
-    case kNormalPriority:
-      // The -1 ensures that the kHighPriority is always greater or equal to
-      // kNormalPriority.
-      return (low_prio + top_prio - 1) / 2;
-    case kHighPriority:
-      return std::max(top_prio - 2, low_prio);
-    case kHighestPriority:
-      return std::max(top_prio - 1, low_prio);
-    case kRealtimePriority:
-      return top_prio;
-  }
-  RTC_DCHECK(false);
-  return low_prio;
-}
 #endif  // defined(WEBRTC_WIN)
 }
 
 PlatformThread::PlatformThread(ThreadRunFunction func,
                                void* obj,
                                const char* thread_name)
     : run_function_(func),
       obj_(obj),
       name_(thread_name ? thread_name : "webrtc"),
 #if defined(WEBRTC_WIN)
@@ skipping 106 matching lines @@
 #endif
   const int min_prio = sched_get_priority_min(policy);
   const int max_prio = sched_get_priority_max(policy);
   if (min_prio == -1 || max_prio == -1) {
     return false;
   }
 
   if (max_prio - min_prio <= 2)
     return false;
 
+  // Convert webrtc priority to system priorities:
   sched_param param;
-  param.sched_priority = ConvertToSystemPriority(priority, min_prio, max_prio);
-  if (pthread_setschedparam(thread_, policy, &param) != 0) {
-    return false;
+  const int top_prio = max_prio - 1;
+  const int low_prio = min_prio + 1;
+  switch (priority) {
+    case kLowPriority:
+      param.sched_priority = low_prio;
+      break;
+    case kNormalPriority:
+      // The -1 ensures that the kHighPriority is always greater or equal to
+      // kNormalPriority.
+      param.sched_priority = (low_prio + top_prio - 1) / 2;
+      break;
+    case kHighPriority:
+      param.sched_priority = std::max(top_prio - 2, low_prio);
+      break;
+    case kHighestPriority:
+      param.sched_priority = std::max(top_prio - 1, low_prio);
+      break;
+    case kRealtimePriority:
+      param.sched_priority = top_prio;
+      break;
   }
-
-  return true;
+  return pthread_setschedparam(thread_, policy, &param) == 0;
 #endif  // defined(WEBRTC_CHROMIUM_BUILD) && defined(WEBRTC_LINUX)
 #endif  // defined(WEBRTC_WIN)
 }
 
 }  // namespace webrtc