Mojofication of the Chrome Audio Rendering Prototype

media/audio/audio_output_controller.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_OUTPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
 
 #include <stdint.h>
 
 #include "base/atomic_ref_count.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
+#include "content/common/media/audio_output.mojom.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_power_monitor.h"
 #include "media/audio/audio_source_diverter.h"
 #include "media/audio/simple_sources.h"
 #include "media/base/media_export.h"
 
 // An AudioOutputController controls an AudioOutputStream and provides data
 // to this output stream. It has an important function that it executes
 // audio operations like play, pause, stop, etc. on a separate thread,
@@ skipping 34 matching lines @@
     : public base::RefCountedThreadSafe<AudioOutputController>,
       public AudioOutputStream::AudioSourceCallback,
       public AudioSourceDiverter,
       NON_EXPORTED_BASE(public AudioManager::AudioDeviceListener)  {
  public:
   // An event handler that receives events from the AudioOutputController. The
   // following methods are called on the audio manager thread.
   class MEDIA_EXPORT EventHandler {
    public:
     virtual void OnCreated() = 0;
+    virtual void OnCreated(
+        content::mojom::AudioOutputStreamPtr stream,
+        const content::mojom::AudioOutput::CreateStreamCallback& callback) = 0;
     virtual void OnPlaying() = 0;
     virtual void OnPaused() = 0;
     virtual void OnError() = 0;
 
    protected:
     virtual ~EventHandler() {}
   };
 
   // A synchronous reader interface used by AudioOutputController for
   // synchronous reading.
@@ skipping 25 matching lines @@
   // thread, and if this is successful, the |event_handler| will receive an
   // OnCreated() call from the same audio manager thread.  |audio_manager| must
   // outlive AudioOutputController.
   // The |output_device_id| can be either empty (default device) or specify a
   // specific hardware device for audio output.
   static scoped_refptr<AudioOutputController> Create(
       AudioManager* audio_manager, EventHandler* event_handler,
       const AudioParameters& params, const std::string& output_device_id,
       SyncReader* sync_reader);
 
+  // Factory method for creating an AudioOutputController.
+  // This also creates and opens an AudioOutputStream on the audio manager
+  // thread, and if this is successful, the |event_handler| will receive an
+  // OnCreated() call from the same audio manager thread.  |audio_manager| must
+  // outlive AudioOutputController.
+  // The |output_device_id| can be either empty (default device) or specify a
+  // specific hardware device for audio output.
+  static scoped_refptr<AudioOutputController> Create(
+      AudioManager* audio_manager,
+      EventHandler* event_handler,
+      const AudioParameters& params,
+      const std::string& output_device_id,
+      SyncReader* sync_reader,
+      content::mojom::AudioOutputStreamPtr stream,
+      const content::mojom::AudioOutput::CreateStreamCallback& callback);
+
   // Indicates whether audio power level analysis will be performed.  If false,
   // ReadCurrentPowerAndClip() can not be called.
   static bool will_monitor_audio_levels() {
 #if defined(OS_ANDROID) || defined(OS_IOS)
     return false;
 #else
     return true;
 #endif
   }
 
@@ skipping 74 matching lines @@
   ~AudioOutputController() override;
 
  private:
   AudioOutputController(AudioManager* audio_manager, EventHandler* handler,
                         const AudioParameters& params,
                         const std::string& output_device_id,
                         SyncReader* sync_reader);
 
   // The following methods are executed on the audio manager thread.
   void DoCreate(bool is_for_device_change);
+  // The following methods are executed on the audio manager thread.
+  void DoCreateMojo(
+      bool is_for_device_change,
+      const content::mojom::AudioOutput::CreateStreamCallback& callback);
   void DoPlay();
   void DoPause();
   void DoClose();
   void DoSetVolume(double volume);
   std::string DoGetOutputDeviceId() const;
   void DoSwitchOutputDevice(const std::string& output_device_id);
   void DoReportError();
   void DoStartDiverting(AudioOutputStream* to_stream);
   void DoStopDiverting();
 
   // Helper method that stops the physical stream.
   void StopStream();
 
   // Helper method that stops, closes, and NULLs |*stream_|.
   void DoStopCloseAndClearStream();
 
   // Checks if a stream was started successfully but never calls OnMoreData().
   void WedgeCheck();
 
   AudioManager* const audio_manager_;
   const AudioParameters params_;
   EventHandler* const handler_;
 
   // Specifies the device id of the output device to open or empty for the
   // default output device.
   std::string output_device_id_;
 
   AudioOutputStream* stream_;
 
+  content::mojom::AudioOutputStreamPtr stream_ptr_;
+
   // When non-NULL, audio is being diverted to this stream.
   AudioOutputStream* diverting_to_stream_;
 
   // The current volume of the audio stream.
   double volume_;
 
   // |state_| may only be used on the audio manager thread.
   State state_;
 
   // SyncReader is used only in low latency mode for synchronous reading.
@@ skipping 18 matching lines @@
   // be accessed while |error_lock_| is held.
   bool ignore_errors_during_stop_close_;
   base::Lock error_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioOutputController);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_