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"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/audio_sync_reader.h"
 #include "content/common/media/audio_messages.h"
 #include "content/public/browser/media_observer.h"
+#include "media/audio/audio_io.h"
 #include "media/audio/shared_memory_util.h"
 #include "media/base/audio_bus.h"
 #include "media/base/limits.h"
 
 using media::AudioBus;
 
 namespace content {
 
 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;
 
+  // When non-NULL, normal audio output is being diverted for audio mirroring.
+  media::AudioOutputStream::AudioSourceCallback* diverted_callback;
+
   // 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),
+      diverted_callback(NULL),
       pending_close(false) {
 }
 
-AudioRendererHost::AudioEntry::~AudioEntry() {}
+AudioRendererHost::AudioEntry::~AudioEntry() {
+  DCHECK(!diverted_callback);
+}
+
+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;
+
+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));
+
+  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;

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

Should this just CHECK() fail on missing entry?

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

Short answer: No, because it's possible for look-ups to fail.  Chrome doesn't
synchronize across render processes (that I'm aware of).

Long answer: I added comment in the code to explain this part of the plumbing
and why it's normal for look-ups here to fail.  Please see that for the details.

+}
+
+// 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) {

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

CHECK() instead?

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

Explained above.

+    return;
+  }
+
+  // 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 outputs to |destination|.  If streams were

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

This seems strange. Are you saying callers can change the diverter target w/o
calling StopMirroring() ? Do you expect a use case for this? If not it seems
simpler to force callers to always call StopMirroring() before the next
StartMirroring().

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

Yes.  Two ways to answer this:

1. Architecture: Let's say two different web pages (or extensions) call into the
tab capture JS API to start a mirroring session.  They want to mirror the same
tab, yet are not aware of each other's existence.  So, there's no way for a
second entity to ask the first to stop mirroring, wait for it to do so, and then
go ahead.  Even if there was, it's not clear we would want to burden web
developers with these details.

2. User intention: Mirroring is a user-initiated action.  Therefore, we
interpret the later action as the pertinent one.  In other words, it's the
user's intention to start mirroring to a new destination rather than maintain
the old mirroring session (which they may have forgotten about).

+  // already diverted to the |old_destination|, move them to the new
+  // |destination|.
+  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) {
+        DCHECK(entry->diverted_callback);
+        old_destination->RemoveInput(entry->diverted_callback);
+      } else {
+        DCHECK(!entry->diverted_callback);
+        entry->diverted_callback = entry->controller->Divert();
+      }
+      destination->AddInput(entry->diverted_callback,
+                            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) {

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

Same CHECK() comment.

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

Explained above.

+    return;
+  }
+
+  MirrorSessionMap::iterator session_it =
+      host->mirror_sessions_.find(render_view_id);
+  if (session_it == host->mirror_sessions_.end() ||

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

Ditto.

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

This "if" check is necessary because StartMirroring() may switch mirroring over
to a new destination.  In that case, we want the new destination to gain control
over stopping mirroring.

+      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->diverted_callback) {
+      destination->RemoveInput(entry->diverted_callback);
+      entry->controller->Revert(entry->diverted_callback);
+      entry->diverted_callback = NULL;
+    }
+  }
+
+  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.
+
+  // If this stream is currently being mirrored, remove it from that mirroring
+  // session.
+  MirrorSessionMap::const_iterator prev_session_it =
+      mirror_sessions_.find(entry->render_view_id);
+  if (prev_session_it != mirror_sessions_.end()) {
+    if (entry->diverted_callback) {
+      prev_session_it->second->RemoveInput(entry->diverted_callback);
+    }
+  }
+
+  entry->render_view_id = render_view_id;
+
+  // If a mirroring session is already active for the RenderView, add this
+  // stream to that mirroring session.
+  MirrorSessionMap::const_iterator next_session_it =
+      mirror_sessions_.find(render_view_id);
+  if (next_session_it != mirror_sessions_.end()) {
+    if (!entry->pending_close) {
+      if (!entry->diverted_callback) {
+        entry->diverted_callback = entry->controller->Divert();
+      }
+      next_session_it->second->AddInput(entry->diverted_callback,
+                                        entry->controller->params());
+    }
+  } else if (entry->diverted_callback) {
+    // Clean-up: The audio stream was removed from the previous mirroring
+    // session, but there is no other mirroring session for it to be added to.
+    // So, "revert the divert."
+    entry->controller->Revert(entry->diverted_callback);
+    entry->diverted_callback = NULL;
+  }
 }
 
 void AudioRendererHost::OnPlayStream(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupById(stream_id);
   if (!entry) {
     SendErrorMessage(stream_id);
     return;
   }
@@ skipping 71 matching lines @@
   for (AudioEntryMap::iterator i = audio_entries_.begin();
        i != audio_entries_.end(); ++i) {
     CloseAndDeleteStream(i->second);
   }
 }
 
 void AudioRendererHost::CloseAndDeleteStream(AudioEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!entry->pending_close) {
+    // If this stream is currently being mirrored, remove it from the mirroring
+    // session.
+    MirrorSessionMap::const_iterator session_it =
+        mirror_sessions_.find(entry->render_view_id);
+    if (session_it != mirror_sessions_.end() && entry->diverted_callback) {
+      session_it->second->RemoveInput(entry->diverted_callback);
+      // Note: We don't call AudioOutputController::Revert() since we're about
+      // to close the controller below.  If we did call Revert(), it would cause
+      // an unnecessary round of immediate starting and stopping.
+    }
+
     entry->controller->Close(
         base::Bind(&AudioRendererHost::DeleteEntry, this, entry));
+    entry->diverted_callback = NULL;
     entry->pending_close = true;
   }
 }
 
 void AudioRendererHost::DeleteEntry(AudioEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Delete the entry when this method goes out of scope.
   scoped_ptr<AudioEntry> entry_deleter(entry);
 
@@ skipping 40 matching lines @@
   return NULL;
 }
 
 media::AudioOutputController* AudioRendererHost::LookupControllerByIdForTesting(
     int stream_id) {
   AudioEntry* const entry = LookupById(stream_id);
   return entry ? entry->controller : NULL;
 }
 
 }  // namespace content