Allow AudioDeviceThread to be created with NORMAL thread priority.

Currently the media::AudioDeviceThread is always created with
REALTIME_AUDIO thread priority. However, when calling from the new
Mirroring Service running in a sandboxed utility process (coming in
future CLs), the REALTIME_AUDIO priority is not allowed due to sandbox
syscall restrictions. Also, since the input audio data is buffered,
there is no need to use REALTIME_AUDIO thread for mirroring.

This CL allows media::AudioDeviceThread to be created with requested
thread priority. There should be no change to existing behavior.

Bug: 850352
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Id9e724b230e14c269f262c1c4c7e2b15ac08a57d
Reviewed-on: https://chromium-review.googlesource.com/1090226
Commit-Queue: Xiangjun Zhang <xjz@chromium.org>
Reviewed-by: Olga Sharonova <olka@chromium.org>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565713}

content/renderer/media/audio/audio_device_factory.cc

@@ -8,6 +8,7 @@
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/media/renderer_audio_input_stream_factory.mojom.h"
@@ -168,7 +169,8 @@ AudioDeviceFactory::NewAudioCapturerSource(int render_frame_id,
 
   return base::MakeRefCounted<media::AudioInputDevice>(
       AudioInputIPCFactory::get()->CreateAudioInputIPC(render_frame_id,
-                                                       session_id));
+                                                       session_id),
+      base::ThreadPriority::REALTIME_AUDIO);
 }
 
 // static

media/audio/audio_device_thread.cc

@@ -40,10 +40,11 @@ void AudioDeviceThread::Callback::InitializeOnAudioThread() {
 
 AudioDeviceThread::AudioDeviceThread(Callback* callback,
                                      base::SyncSocket::Handle socket,
-                                     const char* thread_name)
+                                     const char* thread_name,
+                                     base::ThreadPriority thread_priority)
     : callback_(callback), thread_name_(thread_name), socket_(socket) {
-  CHECK(base::PlatformThread::CreateWithPriority(
-      0, this, &thread_handle_, base::ThreadPriority::REALTIME_AUDIO));
+  CHECK(base::PlatformThread::CreateWithPriority(0, this, &thread_handle_,
+                                                 thread_priority));
 
   DCHECK(!thread_handle_.is_null());
 }

media/audio/audio_device_thread.h

@@ -67,7 +67,8 @@ class MEDIA_EXPORT AudioDeviceThread : public base::PlatformThread::Delegate {
   // Creates and automatically starts the audio thread.
   AudioDeviceThread(Callback* callback,
                     base::SyncSocket::Handle socket,
-                    const char* thread_name);
+                    const char* thread_name,
+                    base::ThreadPriority thread_priority);
 
   // This tells the audio thread to stop and clean up the data; this is a
   // synchronous process and the thread will stop before the method returns.

media/audio/audio_input_device.cc

@@ -86,8 +86,10 @@ class AudioInputDevice::AudioThreadCallback
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
-AudioInputDevice::AudioInputDevice(std::unique_ptr<AudioInputIPC> ipc)
-    : callback_(nullptr),
+AudioInputDevice::AudioInputDevice(std::unique_ptr<AudioInputIPC> ipc,
+                                   base::ThreadPriority thread_priority)
+    : thread_priority_(thread_priority),
+      callback_(nullptr),
       ipc_(std::move(ipc)),
       state_(IDLE),
       agc_is_enabled_(false) {
@@ -247,8 +249,9 @@ void AudioInputDevice::OnStreamCreated(
       kRequestedSharedMemoryCount, callback_,
       base::BindRepeating(&AliveChecker::NotifyAlive,
                           base::Unretained(alive_checker_.get())));
-  audio_thread_ = std::make_unique<AudioDeviceThread>(
-      audio_callback_.get(), socket_handle, "AudioInputDevice");
+  audio_thread_ =
+      std::make_unique<AudioDeviceThread>(audio_callback_.get(), socket_handle,
+                                          "AudioInputDevice", thread_priority_);
 
   state_ = RECORDING;
   ipc_->RecordStream();

media/audio/audio_input_device.h

@@ -53,6 +53,7 @@
 #include "base/memory/read_only_shared_memory_region.h"
 #include "base/optional.h"
 #include "base/sequence_checker.h"
+#include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "media/audio/alive_checker.h"
 #include "media/audio/audio_device_thread.h"
@@ -67,7 +68,8 @@ class MEDIA_EXPORT AudioInputDevice : public AudioCapturerSource,
                                       public AudioInputIPCDelegate {
  public:
   // NOTE: Clients must call Initialize() before using.
-  explicit AudioInputDevice(std::unique_ptr<AudioInputIPC> ipc);
+  AudioInputDevice(std::unique_ptr<AudioInputIPC> ipc,
+                   base::ThreadPriority thread_priority);
 
   // AudioCapturerSource implementation.
   void Initialize(const AudioParameters& params,
@@ -118,6 +120,8 @@ class MEDIA_EXPORT AudioInputDevice : public AudioCapturerSource,
 
   AudioParameters audio_parameters_;
 
+  const base::ThreadPriority thread_priority_;
+
   CaptureCallback* callback_;
 
   // A pointer to the IPC layer that takes care of sending requests over to

media/audio/audio_input_device_unittest.cc

@@ -66,8 +66,8 @@ class MockCaptureCallback : public AudioCapturerSource::CaptureCallback {
 TEST(AudioInputDeviceTest, Noop) {
   base::MessageLoopForIO io_loop;
   MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
-  scoped_refptr<AudioInputDevice> device(
-      new AudioInputDevice(base::WrapUnique(input_ipc)));
+  scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
+      base::WrapUnique(input_ipc), base::ThreadPriority::REALTIME_AUDIO));
 }
 
 ACTION_P(ReportStateChange, device) {
@@ -81,8 +81,8 @@ TEST(AudioInputDeviceTest, FailToCreateStream) {
 
   MockCaptureCallback callback;
   MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
-  scoped_refptr<AudioInputDevice> device(
-      new AudioInputDevice(base::WrapUnique(input_ipc)));
+  scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
+      base::WrapUnique(input_ipc), base::ThreadPriority::REALTIME_AUDIO));
   device->Initialize(params, &callback);
   EXPECT_CALL(*input_ipc, CreateStream(_, _, _, _))
       .WillOnce(ReportStateChange(device.get()));
@@ -117,8 +117,8 @@ TEST(AudioInputDeviceTest, CreateStream) {
   base::test::ScopedTaskEnvironment ste;
   MockCaptureCallback callback;
   MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
-  scoped_refptr<AudioInputDevice> device(
-      new AudioInputDevice(base::WrapUnique(input_ipc)));
+  scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
+      base::WrapUnique(input_ipc), base::ThreadPriority::REALTIME_AUDIO));
   device->Initialize(params, &callback);
 
   EXPECT_CALL(*input_ipc, CreateStream(_, _, _, _))

media/audio/audio_output_device.cc

@@ -14,6 +14,7 @@
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event.h"
@@ -402,7 +403,8 @@ void AudioOutputDevice::OnStreamCreated(
     if (playing_automatically)
       audio_callback_->InitializePlayStartTime();
     audio_thread_.reset(new AudioDeviceThread(
-        audio_callback_.get(), socket_handle, "AudioOutputDevice"));
+        audio_callback_.get(), socket_handle, "AudioOutputDevice",
+        base::ThreadPriority::REALTIME_AUDIO));
   }
 }
 

services/audio/public/cpp/device_factory.cc

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "base/bind.h"
+#include "base/threading/platform_thread.h"
 #include "services/audio/public/cpp/input_ipc.h"
 
 namespace audio {
@@ -18,7 +19,8 @@ scoped_refptr<media::AudioCapturerSource> CreateInputDevice(
   std::unique_ptr<media::AudioInputIPC> ipc = std::make_unique<InputIPC>(
       std::move(connector), device_id, std::move(log));
 
-  return base::MakeRefCounted<media::AudioInputDevice>(std::move(ipc));
+  return base::MakeRefCounted<media::AudioInputDevice>(
+      std::move(ipc), base::ThreadPriority::REALTIME_AUDIO);
 }
 
 scoped_refptr<media::AudioCapturerSource> CreateInputDevice(
@@ -27,7 +29,8 @@ scoped_refptr<media::AudioCapturerSource> CreateInputDevice(
   std::unique_ptr<media::AudioInputIPC> ipc =
       std::make_unique<InputIPC>(std::move(connector), device_id, nullptr);
 
-  return base::MakeRefCounted<media::AudioInputDevice>(std::move(ipc));
+  return base::MakeRefCounted<media::AudioInputDevice>(
+      std::move(ipc), base::ThreadPriority::REALTIME_AUDIO);
 }
 
 }  // namespace audio