Pass task runners to AudioManager constructor.

media/audio/android/audio_manager_android.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/android/audio_manager_android.h"
 
 #include "base/android/build_info.h"
 #include "base/android/context_utils.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
@@ skipping 27 matching lines @@
 }
 
 // Maximum number of output streams that can be open simultaneously.
 const int kMaxOutputStreams = 10;
 
 const int kDefaultInputBufferSize = 1024;
 const int kDefaultOutputBufferSize = 2048;
 
 }  // namespace
 
-AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
-  return new AudioManagerAndroid(audio_log_factory);
+ScopedAudioManagerPtr CreateAudioManager(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
+    AudioLogFactory* audio_log_factory) {
+  return ScopedAudioManagerPtr(new AudioManagerAndroid(
+      std::move(task_runner), std::move(worker_task_runner),
+      audio_log_factory));
 }
 
-AudioManagerAndroid::AudioManagerAndroid(AudioLogFactory* audio_log_factory)
-    : AudioManagerBase(audio_log_factory),
+AudioManagerAndroid::AudioManagerAndroid(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
+    AudioLogFactory* audio_log_factory)
+    : AudioManagerBase(std::move(task_runner),
+                       std::move(worker_task_runner),
+                       audio_log_factory),
       communication_mode_is_on_(false),
       output_volume_override_set_(false),
       output_volume_override_(0) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   // WARNING: This is executed on the UI loop, do not add any code here which
   // loads libraries or attempts to call out into the OS.  Instead add such code
   // to the InitializeOnAudioThread() method below.
 
   // Task must be posted last to avoid races from handing out "this" to the
   // audio thread.
   GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
       &AudioManagerAndroid::InitializeOnAudioThread,
       base::Unretained(this)));
 }
 
 AudioManagerAndroid::~AudioManagerAndroid() {
-  // It's safe to post a task here since Shutdown() will wait for all tasks to
-  // complete before returning.
-  GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
-      &AudioManagerAndroid::ShutdownOnAudioThread, base::Unretained(this)));
-  Shutdown();
+  DCHECK(GetTaskRunner()->BelongsToCurrentThread());

[DaleCurtis, 2016/04/06 22:07:49]

Hmm, this might be a bit dicy in the future since j_audio_manager_ is used by
ReleaseInputStream(), but I suppose at this point there should be zero input
streams which is okay for now.

[alokp, 2016/04/07 00:38:10]

We have a DCHECK_EQ(0, num_input_streams_) in AudioManagerBase destructor, which
should catch this, although I agree it does look dicy. If this is a problem, we
will need to post a task to destroy j_audio_manager_ similar to what we are
doing in Pulse.

[tommi (sloooow) - chröme, 2016/04/07 14:33:40]

What do you think about upgrading that to CHECK_EQ?  I'd like to do that for all
platforms actually, so if we're confident with this requirement being met, maybe
we should do that.  I think it's an important enough design assertion and if we
don't meet it, there's a chance of a use-after-free.

[DaleCurtis, 2016/04/07 17:23:09]

+1 I think we should do this, though it'll be hard to be actionable given the
amount of information available at time of destruction. It won't catch all
problem cases either. The risk case is: previously the thread stopped during
destruction w/ a join, now it will stop after destruction. If anything during
destruction posts another task to the task runner thread doing things with an
audio manager we'll have problems.

+  DVLOG(2) << "Destroying Java part of the audio manager";
+  Java_AudioManagerAndroid_close(base::android::AttachCurrentThread(),
+                                 j_audio_manager_.obj());
+  j_audio_manager_.Reset();
 }
 
 bool AudioManagerAndroid::HasAudioOutputDevices() {
   return true;
 }
 
 bool AudioManagerAndroid::HasAudioInputDevices() {
   return true;
 }
 
@@ skipping 244 matching lines @@
           base::android::GetApplicationContext(),
           reinterpret_cast<intptr_t>(this)));
 
   // Prepare the list of audio devices and register receivers for device
   // notifications.
   Java_AudioManagerAndroid_init(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj());
 }
 
-void AudioManagerAndroid::ShutdownOnAudioThread() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
-  DVLOG(2) << "Destroying Java part of the audio manager";
-  Java_AudioManagerAndroid_close(
-      base::android::AttachCurrentThread(),
-      j_audio_manager_.obj());
-  j_audio_manager_.Reset();
-}
-
 void AudioManagerAndroid::SetCommunicationAudioModeOn(bool on) {
   Java_AudioManagerAndroid_setCommunicationAudioModeOn(
       base::android::AttachCurrentThread(),
       j_audio_manager_.obj(), on);
 }
 
 bool AudioManagerAndroid::SetAudioDevice(const std::string& device_id) {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
 
   // Send the unique device ID to the Java audio manager and make the
@@ skipping 50 matching lines @@
   output_volume_override_ = volume;
 
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   for (OutputStreams::iterator it = streams_.begin();
        it != streams_.end(); ++it) {
     (*it)->SetVolume(volume);
   }
 }
 
 }  // namespace media