Implement MojoAudioRendererSink and use it in UtilityMojoMediaClient

media/audio/audio_device_thread.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/audio_device_thread.h"
 
 #include <limits>
 
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/threading/thread.h"
 
 namespace media {
 
 // AudioDeviceThread::Callback implementation
 
 AudioDeviceThread::Callback::Callback(const AudioParameters& audio_parameters,
                                       base::SharedMemoryHandle memory,
                                       int memory_length,
                                       int total_segments)
     : audio_parameters_(audio_parameters),
@@ skipping 19 matching lines @@
   DCHECK(!shared_memory_.memory());
   MapSharedMemory();
   CHECK(shared_memory_.memory());
 }
 
 // AudioDeviceThread implementation
 
 AudioDeviceThread::AudioDeviceThread(Callback* callback,
                                      base::SyncSocket::Handle socket,
                                      const char* thread_name)
-    : callback_(callback), thread_name_(thread_name), socket_(socket) {
-  CHECK(base::PlatformThread::CreateWithPriority(
-      0, this, &thread_handle_, base::ThreadPriority::REALTIME_AUDIO));
-  DCHECK(!thread_handle_.is_null());
+    : callback_(callback),
+      socket_(socket),
+      thread_(new base::Thread("AudioDevice")) {
+  base::Thread::Options options;
+  options.joinable = true;
+  options.priority = base::ThreadPriority::REALTIME_AUDIO;
+  thread_->StartWithOptions(options);
+  bool started = thread_->WaitUntilThreadStarted();
+  CHECK(started);
+
+  thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioDeviceThread::ThreadMain, base::Unretained(this)));
 }
 
 AudioDeviceThread::~AudioDeviceThread() {
   socket_.Shutdown();
-  if (thread_handle_.is_null())
-    return;
-  base::PlatformThread::Join(thread_handle_);
+  thread_->Stop();
 }
 
 void AudioDeviceThread::ThreadMain() {
-  base::PlatformThread::SetName(thread_name_);
   callback_->InitializeOnAudioThread();
 
   uint32_t buffer_index = 0;
   while (true) {
     uint32_t pending_data = 0;
     size_t bytes_read = socket_.Receive(&pending_data, sizeof(pending_data));
     if (bytes_read != sizeof(pending_data))
       break;
 
     // std::numeric_limits<uint32_t>::max() is a special signal which is
@@ skipping 18 matching lines @@
     // expects. For more details on how this works see
     // AudioSyncReader::WaitUntilDataIsReady().
     ++buffer_index;
     size_t bytes_sent = socket_.Send(&buffer_index, sizeof(buffer_index));
     if (bytes_sent != sizeof(buffer_index))
       break;
   }
 }
 
 }  // namespace media.