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

content/browser/renderer_host/media/audio_renderer_host.cc

 // 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.
 
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
@@ skipping 12 matching lines @@
 struct AudioRendererHost::AudioEntry {
   AudioEntry();
   ~AudioEntry();
 
   // The AudioOutputController that manages the audio stream.
   scoped_refptr<media::AudioOutputController> controller;
 
   // The audio stream ID.
   int stream_id;
 
+  // The routing ID of the source render view.
+  int render_view_id;
+
   // Shared memory for transmission of the audio data.
   base::SharedMemory shared_memory;
 
   // The synchronous reader to be used by the controller. We have the
   // ownership of the reader.
   scoped_ptr<media::AudioOutputController::SyncReader> reader;
 
   // Set to true after we called Close() for the controller.
   bool pending_close;
 };
 
 AudioRendererHost::AudioEntry::AudioEntry()
     : stream_id(0),
+      render_view_id(MSG_ROUTING_NONE),
       pending_close(false) {
 }
 
 AudioRendererHost::AudioEntry::~AudioEntry() {}
 
+AudioRendererHost::MirroringDestination::~MirroringDestination() {}
+
 ///////////////////////////////////////////////////////////////////////////////
 // AudioRendererHost implementations.
 AudioRendererHost::AudioRendererHost(
+    int render_process_id,
     media::AudioManager* audio_manager, MediaObserver* media_observer)
-    : audio_manager_(audio_manager),
+    : render_process_id_(render_process_id),
+      audio_manager_(audio_manager),
       media_observer_(media_observer) {
 }
 
 AudioRendererHost::~AudioRendererHost() {
   DCHECK(audio_entries_.empty());
+  DCHECK(mirror_sessions_.empty());
+}
+
+base::LazyInstance<AudioRendererHost::ActiveHostMap>::Leaky
+    AudioRendererHost::g_host_map_ = LAZY_INSTANCE_INITIALIZER;

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

thinking out loud here... this map is only accessed on the IO thread... instead
of making it global, can we somehow tie it to the IO thread and only make it
accessible from there?

+
+void AudioRendererHost::OnChannelConnected(int32 peer_pid) {
+  g_host_map_.Get().insert(std::make_pair(render_process_id_, this));
+
+  BrowserMessageFilter::OnChannelConnected(peer_pid);
 }
 
 void AudioRendererHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
 
   // Since the IPC channel is gone, close all requested audio streams.
   DeleteEntries();
+
+  while (!mirror_sessions_.empty()) {
+    MirrorSessionMap::iterator it = mirror_sessions_.begin();
+    DoStopMirroring(render_process_id_, it->first, it->second);
+  }
+
+  g_host_map_.Get().erase(render_process_id_);
 }
 
 void AudioRendererHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // media::AudioOutputController::EventHandler implementations.
 void AudioRendererHost::OnCreated(media::AudioOutputController* controller) {
   BrowserThread::PostTask(
@@ skipping 131 matching lines @@
     IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_FlushStream, OnFlushStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_CloseStream, OnCloseStream)
     IPC_MESSAGE_HANDLER(AudioHostMsg_SetVolume, OnSetVolume)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   return handled;
 }
 
+// static
+AudioRendererHost* AudioRendererHost::FromRenderProcessID(
+    int render_process_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Note: It's possible for look-ups to fail since, for example, an
+  // AudioRendererHost could be shutdown before StartMirroring() is called.
+  // It's common for mirroring sessions to target a different render
+  // process/view than the one that will receive the mirrored audio data.
+  // Example sequence of events:
+  //
+  //   1. RenderProcess_1 wants to mirror a tab within RenderProcess_2.
+  //   2. RenderProcess_1 starts sending IPCs to initiate a mirroring session.
+  //   3. In the meantime, RenderProcess_2 is shut down (e.g., tab closed).  The
+  //      AudioRendererHost for RenderProcess_2 is destroyed as a result.
+  //   4. A browser-side entity for RenderProcess_1 attempts to call
+  //      StartMirroring(), but since the AudioRendererHost for RenderProcess_2
+  //      is gone, the look-up here fails.
+
+  ActiveHostMap& host_map = g_host_map_.Get();
+  ActiveHostMap::const_iterator it = host_map.find(render_process_id);
+  return it == host_map.end() ? NULL : it->second;
+}
+
+// static
+void AudioRendererHost::StartMirroring(
+    int render_process_id, int render_view_id,
+    const scoped_refptr<MirroringDestination>& destination) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AudioRendererHost::DoStartMirroring,
+                 render_process_id, render_view_id, destination));
+}
+
+// static
+void AudioRendererHost::DoStartMirroring(
+    int render_process_id, int render_view_id,
+    const scoped_refptr<MirroringDestination>& destination) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(destination);
+
+  AudioRendererHost* const host = FromRenderProcessID(render_process_id);
+  if (!host) {

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

no {}

+    return;  // See comment in FromRenderProcessID().
+  }
+
+  // Insert an entry into the set of active mirroring sessions.  If a mirroring
+  // session is already active for |render_process_id| + |render_view_id|,
+  // replace the entry.
+  MirrorSessionMap::iterator session_it =
+      host->mirror_sessions_.find(render_view_id);
+  scoped_refptr<MirroringDestination> old_destination;
+  if (session_it == host->mirror_sessions_.end()) {
+    host->mirror_sessions_.insert(std::make_pair(render_view_id, destination));
+
+    DVLOG(1) << "Start mirroring render_process_id:render_view_id="
+             << render_process_id << ':' << render_view_id
+             << " --> MirroringDestination@" << destination;
+  } else {
+    old_destination = session_it->second;
+    session_it->second = destination;
+
+    DVLOG(1) << "Switch mirroring of render_process_id:render_view_id="
+             << render_process_id << ':' << render_view_id
+             << "  MirroringDestination@" << old_destination
+             << " --> MirroringDestination@" << destination;
+  }
+
+  // Divert any existing audio streams to |destination|.  If streams were
+  // already diverted to the |old_destination|, remove them.
+  for (AudioEntryMap::const_iterator it = host->audio_entries_.begin();
+       it != host->audio_entries_.end(); ++it) {
+    AudioEntry* const entry = it->second;
+    if (entry->render_view_id == render_view_id && !entry->pending_close) {
+      if (old_destination)
+        entry->controller->RevertDiversion();
+      entry->controller->DivertToStream(
+          destination->AddInput(entry->controller->params()));
+    }
+  }
+}
+
+// static
+void AudioRendererHost::StopMirroring(
+    int render_process_id, int render_view_id,
+    const scoped_refptr<MirroringDestination>& destination) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AudioRendererHost::DoStopMirroring,
+                 render_process_id, render_view_id, destination));
+}
+
+// static
+void AudioRendererHost::DoStopMirroring(
+    int render_process_id, int render_view_id,
+    const scoped_refptr<MirroringDestination>& destination) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  AudioRendererHost* const host = FromRenderProcessID(render_process_id);
+  if (!host) {

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

no {}

+    return;  // See comment in FromRenderProcessID().
+  }
+
+  MirrorSessionMap::iterator session_it =
+      host->mirror_sessions_.find(render_view_id);
+  if (session_it == host->mirror_sessions_.end() ||
+      destination != session_it->second) {
+    return;
+  }
+
+  DVLOG(1) << "Stop mirroring render_process_id:render_view_id="
+           << render_process_id << ':' << render_view_id
+           << " --> MirroringDestination@" << destination;
+
+  // Revert the "divert" for each audio stream currently active in the mirroring
+  // session being stopped.
+  for (AudioEntryMap::const_iterator it = host->audio_entries_.begin();
+       it != host->audio_entries_.end(); ++it) {
+    AudioEntry* const entry = it->second;
+    if (entry->render_view_id == render_view_id && !entry->pending_close) {

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

same here (no {}) and throughout for single line if's (where the condition is a
single line and the body is a single line as well)

+      entry->controller->RevertDiversion();
+    }
+  }
+
+  host->mirror_sessions_.erase(session_it);
+}
+
 void AudioRendererHost::OnCreateStream(
     int stream_id, const media::AudioParameters& params, int input_channels) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(LookupById(stream_id) == NULL);
 
   media::AudioParameters audio_params(params);
   uint32 buffer_size = media::AudioBus::CalculateMemorySize(audio_params);
   DCHECK_GT(buffer_size, 0U);
   DCHECK_LE(buffer_size,
             static_cast<uint32>(media::limits::kMaxPacketSizeInBytes));
@@ skipping 49 matching lines @@
   // If we have created the controller successfully, create an entry and add it
   // to the map.
   entry->stream_id = stream_id;
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
   if (media_observer_)
     media_observer_->OnSetAudioStreamStatus(this, stream_id, "created");
 }
 
 void AudioRendererHost::OnAssociateStreamWithProducer(int stream_id,
                                                       int render_view_id) {
-  // TODO(miu): Will use render_view_id in upcoming change.
-  DVLOG(1) << "AudioRendererHost@" << this
-           << "::OnAssociateStreamWithProducer(stream_id=" << stream_id
-           << ", render_view_id=" << render_view_id << ")";
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  AudioEntry* const entry = LookupById(stream_id);
+  if (!entry) {
+    SendErrorMessage(stream_id);
+    return;
+  }
+
+  if (entry->render_view_id == render_view_id)
+    return;  // No change.
+
+  MirrorSessionMap::const_iterator prev_session_it =
+      mirror_sessions_.find(entry->render_view_id);
+  if (prev_session_it != mirror_sessions_.end()) {
+    entry->controller->RevertDiversion();
+  }
+
+  entry->render_view_id = render_view_id;
+
+  MirrorSessionMap::const_iterator next_session_it =
+      mirror_sessions_.find(render_view_id);
+  if (next_session_it != mirror_sessions_.end()) {
+    entry->controller->DivertToStream(
+        next_session_it->second->AddInput(entry->controller->params()));
+  }
 }
 
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
     return;
   }
@@ skipping 133 matching lines @@
   return NULL;
 }
 
 media::AudioOutputController* AudioRendererHost::LookupControllerByIdForTesting(
     int stream_id) {
   AudioEntry* const entry = LookupById(stream_id);
   return entry ? entry->controller : NULL;
 }
 
 }  // namespace content