Tab Audio Capture: Browser-side connect/disconnect functionality.

content/browser/renderer_host/media/audio_renderer_host.h

Index: content/browser/renderer_host/media/audio_renderer_host.h
diff --git a/content/browser/renderer_host/media/audio_renderer_host.h b/content/browser/renderer_host/media/audio_renderer_host.h
index 44daef21f836cf0ee8da944de1d83fab60b04799..2c82939fc142500e91e0310f8fe9ea503ca5cb6b 100644
--- a/content/browser/renderer_host/media/audio_renderer_host.h
+++ b/content/browser/renderer_host/media/audio_renderer_host.h
@@ -40,6 +40,7 @@
 #include <map>
 
 #include "base/gtest_prod_util.h"
+#include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process.h"
@@ -66,11 +67,34 @@ class CONTENT_EXPORT AudioRendererHost
     : public BrowserMessageFilter,
       public media::AudioOutputController::EventHandler {
  public:
+  // Interface to be implemented by audio mirroring destinations.  See
+  // comments for StartMirroring() and StopMirroring() below.
+  class MirroringDestination
+      : public base::RefCountedThreadSafe<MirroringDestination> {

[DaleCurtis, 2012/12/05 23:35:14]

Do we really need this to be ref counted?

[miu, 2012/12/11 02:30:45]

Yes.  AudioRendererHost operates mainly on the IO thread while
MirroringDestination (to implemented by WebContentsAudioInputStream) will
operate mainly on the audio thread.  Without the ref-counting to guarantee the
object lifetime of MirroringDestination, there are several places where we'd
have to block one thread, waiting for a task to run on the other.

+   public:
+    // Begin pulling data from |callback|, which is providing data in the format
+    // specified by |params|.
+    virtual void AddInput(
+        media::AudioOutputStream::AudioSourceCallback* callback,
+        const media::AudioParameters& params) = 0;
+
+    // Stop pulling data from |callback|.  After this method returns, the caller
+    // can safely destroy the callback.
+    virtual void RemoveInput(
+        media::AudioOutputStream::AudioSourceCallback* callback) = 0;
+
+   protected:
+    friend class base::RefCountedThreadSafe<MirroringDestination>;
+    virtual ~MirroringDestination();
+  };
+
   // Called from UI thread from the owner of this object.
-  AudioRendererHost(media::AudioManager* audio_manager,
+  AudioRendererHost(int render_process_id,
+                    media::AudioManager* audio_manager,
                     MediaObserver* media_observer);
 
   // BrowserMessageFilter implementation.
+  virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;

[DaleCurtis, 2012/12/05 23:35:14]

What is a peer_id?

[miu, 2012/12/11 02:30:45]

The process ID (operating system PID?) of the process at the other end of the
IPC channel.  It doesn't actually matter for our purposes here.  We're just
overriding this method to get notified when the IPC channel is up-and-running.

[tommi (sloooow) - chröme, 2012/12/18 13:41:25]

is int32 needed or is int enough?

[miu, 2012/12/19 00:22:57]

The method signature should probably match what's in BrowserMessageFilter on all
platforms, so int32.  It no longer matters, however, as I don't need this
override anymore.

   virtual void OnChannelClosing() OVERRIDE;
   virtual void OnDestruct() const OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message,
@@ -83,6 +107,18 @@ class CONTENT_EXPORT AudioRendererHost
   virtual void OnError(media::AudioOutputController* controller,
                        int error_code) OVERRIDE;
 
+  // Start/stop mirroring all audio output streams associated with
+  // |render_process_id| + |render_view_id| to |destination|.  Any call to
+  // StartMirroring() must be paired with a later call to StopMirroring() since
+  // a reference is held on the MirroringDestination while the mirroring session
+  // is active.
+  static void StartMirroring(
+      int render_process_id, int render_view_id,
+      const scoped_refptr<MirroringDestination>& destination);
+  static void StopMirroring(
+      int render_process_id, int render_view_id,
+      const scoped_refptr<MirroringDestination>& destination);
+
  private:
   friend class AudioRendererHostTest;
   friend class BrowserThread;
@@ -93,6 +129,8 @@ class CONTENT_EXPORT AudioRendererHost
 
   struct AudioEntry;
   typedef std::map<int, AudioEntry*> AudioEntryMap;
+  typedef std::map<int, scoped_refptr<MirroringDestination> > MirrorSessionMap;
+  typedef std::map<int, AudioRendererHost*> ActiveHostMap;

[tommi (sloooow) - chröme, 2012/12/18 13:41:25]

can you add a note about AudioRendererHost ownership?

[miu, 2012/12/19 00:22:57]

Done.  (in audio_mirroring_manager.h)

 
   virtual ~AudioRendererHost();
 
@@ -164,12 +202,35 @@ class CONTENT_EXPORT AudioRendererHost
 
   media::AudioOutputController* LookupControllerByIdForTesting(int stream_id);
 
+  // Global look-up for the AudioRendererHost instance owned by the
+  // RenderProcessHost specified by |render_process_id|.
+  static AudioRendererHost* FromRenderProcessID(int render_process_id);
+
+  // Implementations for StartMirroring() and StopMirroring() that are run on
+  // the IO BrowserThread.
+  static void DoStartMirroring(
+      int render_process_id, int render_view_id,
+      const scoped_refptr<MirroringDestination>& destination);
+  static void DoStopMirroring(
+      int render_process_id, int render_view_id,
+      const scoped_refptr<MirroringDestination>& destination);
+
+  // ID of the RenderProcessHost that owns this instance.
+  const int render_process_id_;
+
   // A map of stream IDs to audio sources.
   AudioEntryMap audio_entries_;
 
+  // A map of render view IDs to the destination for active mirroring sessions.
+  MirrorSessionMap mirror_sessions_;
+
   media::AudioManager* audio_manager_;
   MediaObserver* media_observer_;
 
+  // Global look-up map for currently-active (i.e., IPC channel is open)
+  // AudioRendererHosts.
+  static base::LazyInstance<ActiveHostMap>::Leaky g_host_map_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioRendererHost);
 };