Factor out AudioOutputDelegate from AudioRendererHost.

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 <memory>
 #include <set>
@@ skipping 53 matching lines @@
 class MEDIA_EXPORT AudioOutputController
     : 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 OnPlaying() = 0;
-    virtual void OnPaused() = 0;
-    virtual void OnError() = 0;
+    virtual void OnControllerCreated() = 0;
+    virtual void OnControllerPlaying() = 0;
+    virtual void OnControllerPaused() = 0;
+    virtual void OnControllerError() = 0;
 
    protected:
     virtual ~EventHandler() {}
   };
 
   // A synchronous reader interface used by AudioOutputController for
   // synchronous reading.
   // TODO(crogers): find a better name for this class and the Read() method
   // now that it can handle synchronized I/O.
   class SyncReader {
@@ skipping 13 matching lines @@
     // be fulfilled (due to timeout).
     virtual void Read(AudioBus* dest) = 0;
 
     // Close this synchronous reader.
     virtual void Close() = 0;
   };
 
   // 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.
+  // OnControllerCreated() 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);
+      AudioManager* audio_manager,
+      EventHandler* event_handler,
+      const AudioParameters& params,
+      const std::string& output_device_id,
+      std::unique_ptr<SyncReader> sync_reader);
 
   // 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 52 matching lines @@
   const AudioParameters& GetAudioParameters() override;
   void StartDiverting(AudioOutputStream* to_stream) override;
   void StopDiverting() override;
   void StartDuplicating(AudioPushSink* sink) override;
   void StopDuplicating(AudioPushSink* sink) override;
 
   // Accessor for AudioPowerMonitor::ReadCurrentPowerAndClip().  See comments in
   // audio_power_monitor.h for usage.  This may be called on any thread.
   std::pair<float, bool> ReadCurrentPowerAndClip();
 
+  // Accessor for enabling communication to the reader.
+  SyncReader* reader() { return sync_reader_.get(); }
+
  protected:
   // Internal state of the source.
   enum State {
     kEmpty,
     kCreated,
     kPlaying,
     kPaused,
     kClosed,
     kError,
   };
 
   // Time constant for AudioPowerMonitor.  See AudioPowerMonitor ctor comments
   // for semantics.  This value was arbitrarily chosen, but seems to work well.
   enum { kPowerMeasurementTimeConstantMillis = 10 };
 
   friend class base::RefCountedThreadSafe<AudioOutputController>;
   ~AudioOutputController() override;
 
  private:
-  AudioOutputController(AudioManager* audio_manager, EventHandler* handler,
+  AudioOutputController(AudioManager* audio_manager,
+                        EventHandler* handler,
                         const AudioParameters& params,
                         const std::string& output_device_id,
-                        SyncReader* sync_reader);
+                        std::unique_ptr<SyncReader> sync_reader);
 
   // The following methods are executed on the audio manager thread.
   void DoCreate(bool is_for_device_change);
   void DoPlay();
   void DoPause();
   void DoClose();
   void DoSetVolume(double volume);
   std::string DoGetOutputDeviceId() const;
   void DoSwitchOutputDevice(const std::string& output_device_id);
   void DoReportError();
@@ skipping 32 matching lines @@
   std::set<AudioPushSink*> duplication_targets_;
   base::Lock duplication_targets_lock_;
 
   // 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.
-  SyncReader* const sync_reader_;
+  const std::unique_ptr<SyncReader> sync_reader_;
 
   // The message loop of audio manager thread that this object runs on.
   const scoped_refptr<base::SingleThreadTaskRunner> message_loop_;
 
   // Scans audio samples from OnMoreData() as input to compute power levels.
   AudioPowerMonitor power_monitor_;
 
   // Flags when we've asked for a stream to start but it never did.
   base::AtomicRefCount on_more_io_data_called_;
   std::unique_ptr<base::OneShotTimer> wedge_timer_;
 
   // Flag which indicates errors received during Stop/Close should be ignored.
   // These errors are generally harmless since a fresh stream is about to be
   // recreated, but if forwarded, renderer side clients may consider them
   // catastrophic and abort their operations.
   //
   // If |stream_| is started then |ignore_errors_during_stop_close_| must only
   // 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_