Site Isolation: RenderView-->RenderFrame for WebContentsVideoCaptureDevice and WebContentsAudioInpu…

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 "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
 #include "media/audio/virtual_audio_input_stream.h"
 #include "media/audio/virtual_audio_output_stream.h"
+#include "media/base/bind_to_current_loop.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 main_render_frame_id,
        AudioMirroringManager* mirroring_manager,
@@ skipping 15 matching lines @@
   void Close();
 
   // Accessor to underlying VirtualAudioInputStream.
   media::VirtualAudioInputStream* mixer_stream() const {
     return mixer_stream_.get();
   }
 
  private:
   friend class base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>;
 
+  typedef AudioMirroringManager::SourceFrameRef SourceFrameRef;
+
   enum State {
     CONSTRUCTED,
     OPENED,
     MIRRORING,
     CLOSED
   };
 
   virtual ~Impl();
 
-  // Returns true if the mirroring target has been permanently lost.
-  bool IsTargetLost() const;
-
   // Notifies the consumer callback that the stream is now dead.
   void ReportError();
 
-  // Start/Stop mirroring by posting a call to AudioMirroringManager on the IO
-  // BrowserThread.
+  // (Re-)Start/Stop mirroring by posting a call to AudioMirroringManager on the
+  // IO BrowserThread.
   void StartMirroring();
   void StopMirroring();
 
   // AudioMirroringManager::MirroringDestination implementation
+  virtual void QueryForMatches(
+      const std::set<SourceFrameRef>& candidates,
+      const MatchesCallback& results_callback) OVERRIDE;
+  void QueryForMatchesOnUIThread(const std::set<SourceFrameRef>& candidates,
+                                 const MatchesCallback& results_callback);
   virtual media::AudioOutputStream* AddInput(
       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);
+  void OnTargetChanged(RenderWidgetHost* target);
 
   // 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.
-  bool target_identified_;
-  int target_render_process_id_;
-  int target_render_view_id_;
+  // Set to true if |tracker_| reports a NULL target, which indicates the target
+  // is permanently lost.
+  bool is_target_lost_;
 
   // 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 main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
     media::VirtualAudioInputStream* mixer_stream)
     : 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),
-      target_identified_(false),
-      target_render_process_id_(-1),
-      target_render_view_id_(-1),
+      is_target_lost_(false),
       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();
 }
 
@@ skipping 19 matching lines @@
 }
 
 void WebContentsAudioInputStream::Impl::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(callback);
 
   if (state_ != OPENED)
     return;
 
   callback_ = callback;
-  if (IsTargetLost()) {
+  if (is_target_lost_) {
     ReportError();
     callback_ = NULL;
     return;
   }
 
   state_ = MIRRORING;
   mixer_stream_->Start(callback);
 
   StartMirroring();
 }
 
 void WebContentsAudioInputStream::Impl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != MIRRORING)
     return;
 
   state_ = OPENED;
 
   mixer_stream_->Stop();
   callback_ = NULL;
 
-  if (!IsTargetLost())
-    StopMirroring();
+  StopMirroring();
 }
 
 void WebContentsAudioInputStream::Impl::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Stop();
 
   if (state_ == OPENED) {
     state_ = CONSTRUCTED;
     tracker_->Stop();
     mixer_stream_->Close();
   }
 
   DCHECK_EQ(CONSTRUCTED, state_);
   state_ = CLOSED;
 }
 
-bool WebContentsAudioInputStream::Impl::IsTargetLost() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!target_identified_)
-    return false;
-  return target_render_process_id_ <= 0 || target_render_view_id_ <= 0;
-}
-
 void WebContentsAudioInputStream::Impl::ReportError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(miu): Need clean-up of AudioInputCallback interface in a future
   // change, since its only implementation ignores the first argument entirely
   callback_->OnError(NULL);
 }
 
 void WebContentsAudioInputStream::Impl::StartMirroring() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioMirroringManager::StartMirroring,
                  base::Unretained(mirroring_manager_),
-                 target_render_process_id_, target_render_view_id_,
                  make_scoped_refptr(this)));
 }
 
 void WebContentsAudioInputStream::Impl::StopMirroring() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioMirroringManager::StopMirroring,
                  base::Unretained(mirroring_manager_),
-                 target_render_process_id_, target_render_view_id_,
                  make_scoped_refptr(this)));
 }
 
+void WebContentsAudioInputStream::Impl::QueryForMatches(
+    const std::set<SourceFrameRef>& candidates,
+    const MatchesCallback& results_callback) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&Impl::QueryForMatchesOnUIThread,
+                 this,
+                 candidates,
+                 media::BindToCurrentLoop(results_callback)));
+}
+
+void WebContentsAudioInputStream::Impl::QueryForMatchesOnUIThread(
+    const std::set<SourceFrameRef>& candidates,
+    const MatchesCallback& results_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  std::set<SourceFrameRef> matches;
+  WebContents* const contents = tracker_->web_contents();
+  if (contents) {
+    // Add each ID to |matches| if it maps to a RenderFrameHost that maps to the
+    // currently-tracked WebContents.
+    for (std::set<SourceFrameRef>::const_iterator i = candidates.begin();
+         i != candidates.end(); ++i) {
+      WebContents* const contents_containing_frame =
+          WebContents::FromRenderFrameHost(
+              RenderFrameHost::FromID(i->first, i->second));
+      if (contents_containing_frame == contents)
+        matches.insert(*i);
+    }
+  }
+
+  results_callback.Run(matches);
+}
+
 media::AudioOutputStream* WebContentsAudioInputStream::Impl::AddInput(
     const media::AudioParameters& params) {
   // Note: The closure created here holds a reference to "this," which will
   // guarantee the VirtualAudioInputStream (mixer_stream_) outlives the
   // VirtualAudioOutputStream.
   return new media::VirtualAudioOutputStream(
       params,
       mixer_stream_.get(),
       base::Bind(&Impl::ReleaseInput, this));
 }
 
 void WebContentsAudioInputStream::Impl::ReleaseInput(
     media::VirtualAudioOutputStream* stream) {
   delete stream;
 }
 
-void WebContentsAudioInputStream::Impl::OnTargetChanged(int render_process_id,
-                                                        int render_view_id) {
+void WebContentsAudioInputStream::Impl::OnTargetChanged(
+    RenderWidgetHost* target) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (target_identified_ &&
-      target_render_process_id_ == render_process_id &&
-      target_render_view_id_ == render_view_id) {
-    return;
-  }
-
-  DVLOG(1) << "Target RenderView has changed from "
-           << target_render_process_id_ << ':' << target_render_view_id_
-           << " to " << render_process_id << ':' << render_view_id;
-
-  if (state_ == MIRRORING)
-    StopMirroring();
-
-  target_identified_ = true;
-  target_render_process_id_ = render_process_id;
-  target_render_view_id_ = render_view_id;
+  is_target_lost_ = !target;
 
   if (state_ == MIRRORING) {
-    if (IsTargetLost()) {
+    if (is_target_lost_) {
       ReportError();
       Stop();
     } else {
       StartMirroring();
     }
   }
 }
 
 // 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 main_render_frame_id;
   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
           device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
   return new WebContentsAudioInputStream(
       render_process_id, main_render_frame_id,
       audio_mirroring_manager,
-      new WebContentsTracker(),
+      new WebContentsTracker(false),
       new media::VirtualAudioInputStream(
           params, worker_task_runner,
           media::VirtualAudioInputStream::AfterCloseCallback()));
 }
 
 WebContentsAudioInputStream::WebContentsAudioInputStream(
     int render_process_id, int main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
     media::VirtualAudioInputStream* mixer_stream)
@@ skipping 33 matching lines @@
 
 void WebContentsAudioInputStream::SetAutomaticGainControl(bool enabled) {
   impl_->mixer_stream()->SetAutomaticGainControl(enabled);
 }
 
 bool WebContentsAudioInputStream::GetAutomaticGainControl() {
   return impl_->mixer_stream()->GetAutomaticGainControl();
 }
 
 }  // namespace content