namespace media {
class AudioOutputStream;
}

namespace content {

class CONTENT_EXPORT AudioMirroringManager {
 public:
  // Interface for diverting audio data to an alternative AudioOutputStream.
  typedef media::AudioSourceDiverter Diverter;

  // Interface to be implemented by audio mirroring destinations.  See comments
  // for StartMirroring() and StopMirroring() below.
  class MirroringDestination {
   public:
    // Create a consumer of audio data in the format specified by |params|, and
    // connect it as an input to mirroring.  When Close() is called on the
    // returned AudioOutputStream, the input is disconnected and the object
    // becomes invalid.
    virtual media::AudioOutputStream* AddInput(
        const media::AudioParameters& params) = 0;

   protected:
    virtual ~MirroringDestination() {}
  };

  AudioMirroringManager();

  virtual ~AudioMirroringManager();

  // Add/Remove a diverter for an audio stream with a known RenderView target
  // (represented by |render_process_id| + |render_view_id|).  Multiple
  // diverters may be added for the same target.  |diverter| must live until
  // after RemoveDiverter() is called.
  //
  // Re-entrancy warning: These methods should not be called by a Diverter
  // during a Start/StopDiverting() invocation.
  virtual void AddDiverter(int render_process_id, int render_view_id,
                           Diverter* diverter);
  virtual void RemoveDiverter(int render_process_id, int render_view_id,
                              Diverter* diverter);

  // Start/stop mirroring all audio output streams associated with a RenderView
  // target (represented by |render_process_id| + |render_view_id|) to
  // |destination|.  |destination| must live until after StopMirroring() is
  // called.
  virtual void StartMirroring(int render_process_id, int render_view_id,
                              MirroringDestination* destination);
  virtual void StopMirroring(int render_process_id, int render_view_id,
                             MirroringDestination* destination);

 private:
  // A mirroring target is a RenderView identified by a
  // <render_process_id, render_view_id> pair.
  typedef std::pair<int, int> Target;

  // Note: Objects in these maps are not owned.
  typedef std::multimap<Target, Diverter*> DiverterMap;
  typedef std::map<Target, MirroringDestination*> SessionMap;

  // Currently-active divertable audio streams.
  DiverterMap diverters_;

  // Currently-active mirroring sessions.
  SessionMap sessions_;

  DISALLOW_COPY_AND_ASSIGN(AudioMirroringManager);
};

}  // namespace content

#endif  // CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_
