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

content/browser/renderer_host/media/audio_mirroring_manager.h

Index: content/browser/renderer_host/media/audio_mirroring_manager.h
diff --git a/content/browser/renderer_host/media/audio_mirroring_manager.h b/content/browser/renderer_host/media/audio_mirroring_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7a20a80eb4f42cc1303e8d1d55cc6ec144cdf9a
--- /dev/null
+++ b/content/browser/renderer_host/media/audio_mirroring_manager.h
@@ -0,0 +1,133 @@
+// 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.
+//
+// AudioMirroringManager is a singleton object that maintains a set of active
+// audio mirroring destinations and auto-connects/disconnects audio streams
+// to/from those destinations.  It is meant to be used exclusively on the IO
+// BrowserThread.
+//
+// How it works:
+//
+//   1. AudioRendererHost gets a CreateStream message from the render process
+//      and, among other things, creates an AudioOutputController to control the
+//      audio data flow between the render and browser processes.
+//   2. At some point, AudioRendererHost receives an "associate with render view"

[tommi (sloooow) - chröme, 2012/12/19 12:27:54]

80+

[miu, 2012/12/28 23:03:49]

Done.

+//      message.  Among other actions, it registers the AudioOutputController
+//      with AudioMirroringManager (as a Diverter).
+//   3. A user request to mirror all the audio for a single RenderView is made.
+//      A MirroringDestination is created, and StartMirroring() is called to
+//      begin the mirroring session.  This causes AudioMirroringManager to
+//      instruct any matching Diverters to divert their audio data to the
+//      MirroringDestination.
+//
+// #2 and #3 above may occur in any order, as it is the job of
+// AudioMirroringManager to realize when the players can be "matched up."
+
+#ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_MIRRORING_MANAGER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_MIRRORING_MANAGER_H_
+
+#include <map>
+#include <utility>
+
+#include "base/basictypes.h"
+#include "content/common/content_export.h"
+
+template <typename T> struct StaticMemorySingletonTraits;
+
+namespace media {
+class AudioOutputStream;
+class AudioParameters;
+}
+
+namespace content {
+
+class CONTENT_EXPORT AudioMirroringManager {
+ public:
+  // Interface for diverting audio data to an alternative AudioOutputStream.
+  class Diverter {
+   public:
+    // Returns the audio parameters of the the divertable audio data.
+    virtual const media::AudioParameters& GetAudioParameters() = 0;
+
+    // Start providing audio data to the given |stream|, which is in an unopened
+    // state.  |stream| is under the control of the Diverter until
+    // StopDiverting() is called.
+    virtual void StartDiverting(media::AudioOutputStream* stream) = 0;
+
+    // Stops diverting audio data to the stream.  The Diverter is responsible
+    // for closing the stream.
+    virtual void StopDiverting() = 0;
+
+   protected:
+    virtual ~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();
+  };
+
+  static AudioMirroringManager* GetInstance();
+
+  // 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.
+  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.

[tommi (sloooow) - chröme, 2012/12/19 12:27:54]

80+

[miu, 2012/12/28 23:03:49]

Done.

+  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);
+
+ protected:
+  friend struct StaticMemorySingletonTraits<AudioMirroringManager>;
+
+  AudioMirroringManager();
+  virtual ~AudioMirroringManager();
+
+  // Inject an alternative implementation for unit testing, to be returned by
+  // GetInstance().
+  static void SetInstanceForTesting(AudioMirroringManager* test_instance);

[tommi (sloooow) - chröme, 2012/12/19 12:27:54]

is there no better way to support testing?

This anti pattern can cause flakiness and hide bugs.  There's no guarantee that
a test will properly cleanup after itself and the value of the pointer from one
test can affect the results of the next one etc.  I'd really like to avoid this
approach if at all possible.

[miu, 2012/12/28 23:03:49]

Done.  Used dependency injection via the AudioRendererHost ctor so test code
could pass in the mock AudioMirroringManager instance (in
audio_renderer_host_unittest.cc).

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

[tommi (sloooow) - chröme, 2012/12/19 12:27:54]

why not just define a struct?  Remembering first and second is prone to errors.

[miu, 2012/12/28 23:03:49]

Two reasons:

1. It's only used as a key in the maps.  There are no references to "first" and
"second" in audio_mirroring_mangaer.cc.

2. We get operator<() with the desired semantics for free.

+
+  // 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_;
+
+  // If not-NULL, this is returned in calls to GetInstance().
+  static AudioMirroringManager* test_instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioMirroringManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_MIRRORING_MANAGER_H_