[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

content/browser/media/capture/web_contents_audio_input_stream.cc

 // Copyright (c) 2013 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/media/capture/web_contents_audio_input_stream.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/capture/web_contents_capture_util.h"
 #include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/audio/virtual_audio_input_stream.h"
 #include "media/audio/virtual_audio_output_stream.h"
 
 namespace content {
 
 class WebContentsAudioInputStream::Impl
     : public base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>,
       public AudioMirroringManager::MirroringDestination {
  public:
   // Takes ownership of |mixer_stream|.  The rest outlive this instance.
-  Impl(int render_process_id, int render_view_id,
+  Impl(int render_process_id, int main_render_frame_id,

[ncarter (slow), 2014/07/10 01:17:51]

Interesting, this points to a possible hurdle (which in no way needs to be
addressed now). Do you think it will be feasible, in oopif, to capture audio
from all the (cross-process) frames of a page?

Situations like a youtube player inside of an iframe could be imagined to be
fairly common.

[miu, 2014/07/10 22:16:12]

Yes.  I've prototyped a solution that seems to work well, with some unfortunate
added complexity: The problem at-hand is that AudioMirroringManager is trying to
match audio streams, associated by render frame routing IDs, against
MirroringDestinations that want the streams from multiple render frames (for a
tab).  To accomplish this, I've prototyped an asynchronous "query" API where
AudioMirroringManager will ask a MirroringDestination whether it wants to
consume audio for a specific render frame.  The API has to be asynchronous
because we have to hop from the IO thread to the UI thread to execute such a
query.

Once this change lands, I'll rebase my prototype, determine whether it still
looks like the right solution, and clean it up for review.

[ncarter (slow), 2014/07/11 22:32:24]

Pretty cool. Glad to hear you're on top of it.

        AudioMirroringManager* mirroring_manager,
        const scoped_refptr<WebContentsTracker>& tracker,
        media::VirtualAudioInputStream* mixer_stream);
 
   // Open underlying VirtualAudioInputStream and start tracker.
   bool Open();
 
   // Start the underlying VirtualAudioInputStream and instruct
   // AudioMirroringManager to begin a mirroring session.
   void Start(AudioInputCallback* callback);
@@ skipping 38 matching lines @@
       const media::AudioParameters& params) OVERRIDE;
 
   // Callback which is run when |stream| is closed.  Deletes |stream|.
   void ReleaseInput(media::VirtualAudioOutputStream* stream);
 
   // Called by WebContentsTracker when the target of the audio mirroring has
   // changed.
   void OnTargetChanged(int render_process_id, int render_view_id);
 
   // Injected dependencies.
+  const int initial_render_process_id_;
+  const int initial_main_render_frame_id_;
   AudioMirroringManager* const mirroring_manager_;
   const scoped_refptr<WebContentsTracker> tracker_;
   // The AudioInputStream implementation that handles the audio conversion and
   // mixing details.
   const scoped_ptr<media::VirtualAudioInputStream> mixer_stream_;
 
   State state_;
 
   // Current audio mirroring target.
   int target_render_process_id_;
   int target_render_view_id_;
 
   // Current callback used to consume the resulting mixed audio data.
   AudioInputCallback* callback_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(Impl);
 };
 
 WebContentsAudioInputStream::Impl::Impl(
-    int render_process_id, int render_view_id,
+    int render_process_id, int main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
     media::VirtualAudioInputStream* mixer_stream)
-    : mirroring_manager_(mirroring_manager),
-      tracker_(tracker), mixer_stream_(mixer_stream), state_(CONSTRUCTED),
-      target_render_process_id_(render_process_id),
-      target_render_view_id_(render_view_id),
+    : initial_render_process_id_(render_process_id),
+      initial_main_render_frame_id_(main_render_frame_id),
+      mirroring_manager_(mirroring_manager),
+      tracker_(tracker),
+      mixer_stream_(mixer_stream),
+      state_(CONSTRUCTED),
+      // TODO(miu): This hack for initializing target_render_XXX_id_ is needed
+      // so IsTargetLost() won't prematurely return false when called in Start()
+      // below.  This will be removed in a soon-upcoming change when all this
+      // code is migrated away from using RenderViewHosts (for cross-site
+      // isolation).

[ncarter (slow), 2014/07/10 01:17:51]

So -- it seems like this workaround is needed because this object is created on
the IO thread to target an initial frame routing_id, but some of the code hasn't
been switched over to use frame routing_ids -- and because we're not on the UI
thread, we can't easily get from the frame to the view.

I'd consider using a bool parameter (target_identified_ ?) on the side, instead
of using kintmax (which usually means MSG_ROUTING_CONTROL). With the boolean you
probably wouldn't need quite as long a comment.

[miu, 2014/07/10 22:16:12]

Done.

+      target_render_process_id_(kint32max),
+      target_render_view_id_(kint32max),
       callback_(NULL) {
   DCHECK(mirroring_manager_);
   DCHECK(tracker_.get());
   DCHECK(mixer_stream_.get());
 
   // WAIS::Impl can be constructed on any thread, but will DCHECK that all
   // its methods from here on are called from the same thread.
   thread_checker_.DetachFromThread();
 }
 
 WebContentsAudioInputStream::Impl::~Impl() {
   DCHECK(state_ == CONSTRUCTED || state_ == CLOSED);
 }
 
 bool WebContentsAudioInputStream::Impl::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK_EQ(CONSTRUCTED, state_) << "Illegal to Open more than once.";
 
   if (!mixer_stream_->Open())
     return false;
 
   state_ = OPENED;
 
   tracker_->Start(
-      target_render_process_id_, target_render_view_id_,
+      initial_render_process_id_, initial_main_render_frame_id_,
       base::Bind(&Impl::OnTargetChanged, this));
 
   return true;
 }
 
 void WebContentsAudioInputStream::Impl::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(callback);
 
   if (state_ != OPENED)
@@ skipping 125 matching lines @@
   }
 }
 
 // static
 WebContentsAudioInputStream* WebContentsAudioInputStream::Create(
     const std::string& device_id,
     const media::AudioParameters& params,
     const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
     AudioMirroringManager* audio_mirroring_manager) {
   int render_process_id;
-  int render_view_id;
+  int main_render_frame_id;
   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
-          device_id, &render_process_id, &render_view_id)) {
+          device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
   return new WebContentsAudioInputStream(
-      render_process_id, render_view_id,
+      render_process_id, main_render_frame_id,
       audio_mirroring_manager,
       new WebContentsTracker(),
       new media::VirtualAudioInputStream(
           params, worker_task_runner,
           media::VirtualAudioInputStream::AfterCloseCallback()));
 }
 
 WebContentsAudioInputStream::WebContentsAudioInputStream(
-    int render_process_id, int render_view_id,
+    int render_process_id, int main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
     media::VirtualAudioInputStream* mixer_stream)
-    : impl_(new Impl(render_process_id, render_view_id,
+    : impl_(new Impl(render_process_id, main_render_frame_id,
                      mirroring_manager, tracker, mixer_stream)) {}
 
 WebContentsAudioInputStream::~WebContentsAudioInputStream() {}
 
 bool WebContentsAudioInputStream::Open() {
   return impl_->Open();
 }
 
 void WebContentsAudioInputStream::Start(AudioInputCallback* callback) {
   impl_->Start(callback);
@@ skipping 22 matching lines @@
 
 void WebContentsAudioInputStream::SetAutomaticGainControl(bool enabled) {
   impl_->mixer_stream()->SetAutomaticGainControl(enabled);
 }
 
 bool WebContentsAudioInputStream::GetAutomaticGainControl() {
   return impl_->mixer_stream()->GetAutomaticGainControl();
 }
 
 }  // namespace content