Pass task runners to AudioManager constructor.

media/audio/audio_manager.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_MANAGER_H_
 #define MEDIA_AUDIO_AUDIO_MANAGER_H_
 
 #include <string>
 
 #include "base/macros.h"
@@ skipping 31 matching lines @@
   // AudioManager. After this is called, all static AudioManager::Create*
   // methods will return an instance of AudioManager provided by |factory|. This
   // call may be made at most once per process, and before any calls to static
   // AudioManager::Create* methods. This method takes ownership of |factory|,
   // which must not be NULL.
   static void SetFactory(AudioManagerFactory* factory);
 
   // Construct the audio manager; only one instance is allowed.  The manager
   // will forward CreateAudioLog() calls to the provided AudioLogFactory; as
   // such |audio_log_factory| must outlive the AudioManager.
+  // DO NOT DELETE the returned instance. Use AudioManager::Destroy.
   static AudioManager* Create(AudioLogFactory* audio_log_factory);

[DaleCurtis, 2016/03/18 00:19:10]

Hmm, I thought you were changing this to Create(..., |task_runner|)? Then you
can just say that AudioManager must be deleted on |task_runner|.

[alokp, 2016/03/18 00:35:19]

I wanted to keep task_runner an internal detail of AudioManager implementation.
As a client of AudioManager I do not care which task_runner is used. I should be
able to just call AudioManager::Create and rely on the platform implementation
to choose an appropriate thread.

Otherwise how do you propose BrowserMainLoop get a task_runner to pass into
AudioManager::Create?

We could add a static AudioManager::GetRecommendedTaskRunner to be implemented
by various platforms. Is this what you had in mind?

[DaleCurtis, 2016/03/18 00:40:41]

No, I was expecting that you would require the task runner to be passed in
always or at the very least that you'd have one method which took no task runner
and used a default and a second which allowed one to be passed in.
Alternatively, BML would have it's own base::Thread it starts and passes the
task runner in for on non-OSX, non-Cast platforms.

This would help both your use case and our test situation immensely since we
have a ton of tests which have to hop to the platform default thread instead of
just using a test task runner.

[alokp, 2016/03/18 06:46:52]

I was under the impression that those tests were intentionally written that way
to test AM in multi-threaded environment :D

Passing the task runners into Create SGTM. PTAL at the latest patch that
combines the various Create functions into one and also passes the task runners.
The task runners are optional to allow the platform to choose a default one if
not specified.

It should be now trivial to update those tests to use a test task runner. I can
do that in follow-up patch.

 
   // Similar to Create() except also schedules a monitor on the given task
   // runner to ensure the audio thread is not stuck for more than 60 seconds; if
   // a hang is detected, the process will be crashed.  See EnableHangMonitor().
+  // DO NOT DELETE the returned instance. Use AudioManager::Destroy.
   static AudioManager* CreateWithHangTimer(
       AudioLogFactory* audio_log_factory,
       const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner);
 
   // Similar to Create() except uses a FakeAudioLogFactory for testing.
+  // DO NOT DELETE the returned instance. Use AudioManager::Destroy.
   static AudioManager* CreateForTesting();
 
+  // Helper function to ensure that AudioManager is properly shutdown
+  // and destroyed on the audio thread.
+  static void Destroy(AudioManager* instance);
+
   // Enables non-crash dumps when audio thread hangs are detected.
   // TODO(dalecurtis): There are no callers to this function at present. A list
   // of bad drivers has been given to Microsoft. This should be re-enabled in
   // the future if Microsoft is able to triage third party drivers.
   // See http://crbug.com/422522
   static void EnableCrashKeyLoggingForAudioThreadHangs();
 
 #if defined(OS_LINUX)
   // Sets the name of the audio source as seen by external apps. Only actually
   // used with PulseAudio as of this writing.
@@ skipping 97 matching lines @@
   // Returns NULL if the combination of the parameters is not supported, or if
   // we have reached some other platform specific limit.
   //
   // Do not free the returned AudioInputStream. It is owned by AudioManager.
   // When you are done with it, call |Stop()| and |Close()| to release it.
   virtual AudioInputStream* MakeAudioInputStream(
       const AudioParameters& params,
       const std::string& device_id) = 0;
 
   // Returns the task runner used for audio IO.
-  virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() = 0;
+  // TODO(alokp): Rename to task_runner().
+  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() const {
+    return task_runner_;
+  }
 
   // Heavyweight tasks should use GetWorkerTaskRunner() instead of
   // GetTaskRunner(). On most platforms they are the same, but some share the
   // UI loop with the audio IO loop.
-  virtual scoped_refptr<base::SingleThreadTaskRunner> GetWorkerTaskRunner() = 0;
+  // TODO(alokp): Rename to worker_task_runner().
+  scoped_refptr<base::SingleThreadTaskRunner> GetWorkerTaskRunner() const {
+    return worker_task_runner_;
+  }
 
   // Allows clients to listen for device state changes; e.g. preferred sample
   // rate or channel layout changes.  The typical response to receiving this
   // callback is to recreate the stream.
   class AudioDeviceListener {
    public:
     virtual void OnDeviceChange() = 0;
   };
 
   virtual void AddOutputDeviceChangeListener(AudioDeviceListener* listener) = 0;
@@ skipping 26 matching lines @@
   // GetWorkerTaskRunner()).
   virtual std::string GetAssociatedOutputDeviceID(
       const std::string& input_device_id) = 0;
 
   // Create a new AudioLog object for tracking the behavior for one or more
   // instances of the given component.  See AudioLogFactory for more details.
   virtual scoped_ptr<AudioLog> CreateAudioLog(
       AudioLogFactory::AudioComponent component) = 0;
 
  protected:
-  AudioManager();
+  AudioManager(
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner);
 
  private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner_;
   DISALLOW_COPY_AND_ASSIGN(AudioManager);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_MANAGER_H_