base: Support setting thread priorities generically.

media/audio/cross_process_notification_win.cc

 // 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.
 
 #include "media/audio/cross_process_notification.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/platform_thread.h"
 #include "base/win/scoped_handle.h"
@@ skipping 103 matching lines @@
     DWORD event_count = MAXIMUM_WAIT_OBJECTS;
     int thread_signaled_event = -1;
     scoped_ptr<ExtraWaitThread> extra_wait_thread;
     if (count_ > (MAXIMUM_WAIT_OBJECTS - 1)) {
       std::copy(&events_[0], &events_[MAXIMUM_WAIT_OBJECTS - 2], &events[1]);
 
       extra_wait_thread.reset(new ExtraWaitThread(stop_,
           &events_[MAXIMUM_WAIT_OBJECTS - 2],
           count_ - (MAXIMUM_WAIT_OBJECTS - 2),
           &thread_signaled_event));
-      base::PlatformThread::Create(0, extra_wait_thread.get(), &next_thread);
+      base::PlatformThreadHandle handle;
+      base::PlatformThread::Create(0, extra_wait_thread.get(), &handle);
+      next_thread = handle.platform_handle();
 
       event_count = MAXIMUM_WAIT_OBJECTS;
       events[MAXIMUM_WAIT_OBJECTS - 1] = next_thread;
     } else {
       std::copy(&events_[0], &events_[count_], &events[1]);
       event_count = count_ + 1;
     }
 
     DWORD wait = ::WaitForMultipleObjects(event_count, &events[0], FALSE,
                                           INFINITE);
     if (wait >= WAIT_OBJECT_0 && wait < (WAIT_OBJECT_0 + event_count)) {
       wait -= WAIT_OBJECT_0;
       if (wait == 0) {
         // The stop event was signaled.  Check if it was signaled by a
         // sub thread.  In case our sub thread had to spin another thread (and
         // so on), we must wait for ours to exit before we can check the
         // propagated event offset.
         if (next_thread) {
-          base::PlatformThread::Join(next_thread);
+          base::PlatformThread::Join(base::PlatformThreadHandle(next_thread));
           next_thread = NULL;
         }
         if (thread_signaled_event != -1)
           *signaled_event_ = thread_signaled_event + (MAXIMUM_WAIT_OBJECTS - 2);
       } else if (events[wait] == next_thread) {
         NOTREACHED();
       } else {
         *signaled_event_ = static_cast<int>(wait);
         SetEvent(stop_);
       }
     } else {
       NOTREACHED();
     }
 
     if (next_thread)
-      base::PlatformThread::Join(next_thread);
+      base::PlatformThread::Join(base::PlatformThreadHandle(next_thread));
   }
 
  private:
   HANDLE stop_;
   HANDLE* events_;
   size_t count_;
   int* signaled_event_;
   DISALLOW_COPY_AND_ASSIGN(ExtraWaitThread);
 };
 }  // end namespace
@@ skipping 55 matching lines @@
     // being signaled).
 
     int thread_signaled_event = -1;
     ExtraWaitThread wait_thread(stop, &handles[MAXIMUM_WAIT_OBJECTS - 1],
         notifications.size() - (MAXIMUM_WAIT_OBJECTS - 1),
         &thread_signaled_event);
     base::PlatformThreadHandle thread;
     base::PlatformThread::Create(0, &wait_thread, &thread);
     HANDLE events[MAXIMUM_WAIT_OBJECTS];
     std::copy(&handles[0], &handles[MAXIMUM_WAIT_OBJECTS - 1], &events[0]);
-    events[MAXIMUM_WAIT_OBJECTS - 1] = thread;
+    events[MAXIMUM_WAIT_OBJECTS - 1] = thread.platform_handle();
     wait = ::WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, &events[0], FALSE,
                                     INFINITE);
     wait_failed = wait < WAIT_OBJECT_0 ||
                   wait >= (WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS);
     if (wait == WAIT_OBJECT_0 + (MAXIMUM_WAIT_OBJECTS - 1)) {
       if (thread_signaled_event < 0) {
         wait_failed = true;
         NOTREACHED();
       } else {
         wait = WAIT_OBJECT_0 + (MAXIMUM_WAIT_OBJECTS - 2) +
@@ skipping 13 matching lines @@
     CHECK(ok);
     ret = (wait + wait_offset) % notifications.size();
     DCHECK_EQ(handles[wait], notifications[ret]->other_.Get());
   } else {
     NOTREACHED();
   }
 
   CHECK_NE(ret, -1);
   return ret;
 }