Reland "Migrate MediaStreamDispatcherHost to be per frame"

This is a reland of 2b33f99.

Original change's description:
> Migrate MediaStreamDispatcherHost to be per frame
>
> Currently, there is only one MediaStreamDispatcherHost per renderer
> process, but almost all its methods require a frame ID to be supplied
> by the caller. This CL migrates this object to be per frame.
>
> Bug: 807274
> Change-Id: I0b7f93e067b789cea5eba020374eb6da243e4890
> Reviewed-on: https://chromium-review.googlesource.com/894864
> Reviewed-by: Guido Urdaneta <guidou@chromium.org>
> Reviewed-by: Avi Drissman <avi@chromium.org>
> Reviewed-by: Tom Sepez <tsepez@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#533970}

TBR=guidou, avi, tsepez

Bug: 807274
Change-Id: Idca20b52a27123cabfbbb55fe570c97a582d4e7a
Reviewed-on: https://chromium-review.googlesource.com/897321
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#534010}

content/browser/frame_host/render_frame_host_impl.cc

@@ -66,6 +66,7 @@
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/browser/renderer_host/media/audio_input_delegate_impl.h"
 #include "content/browser/renderer_host/media/media_devices_dispatcher_host.h"
+#include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
@@ -106,7 +107,6 @@
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_plugin_guest_manager.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
@@ -3227,6 +3227,12 @@ void RenderFrameHostImpl::RegisterMojoInterfaces() {
                    GetRoutingID(),
                    base::Unretained(media_stream_manager)),
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
+
+    registry_->AddInterface(
+        base::BindRepeating(
+            &RenderFrameHostImpl::CreateMediaStreamDispatcherHost,
+            base::Unretained(this), base::Unretained(media_stream_manager)),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
 #endif
 
@@ -4364,6 +4370,19 @@ void RenderFrameHostImpl::CreateAudioOutputStreamFactory(
           factory_context, GetRoutingID(), std::move(request));
 }
 
+#if BUILDFLAG(ENABLE_WEBRTC)
+void RenderFrameHostImpl::CreateMediaStreamDispatcherHost(
+    MediaStreamManager* media_stream_manager,
+    mojom::MediaStreamDispatcherHostRequest request) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!media_stream_dispatcher_host_) {
+    media_stream_dispatcher_host_.reset(new MediaStreamDispatcherHost(
+        GetProcess()->GetID(), GetRoutingID(), media_stream_manager));
+  }
+  media_stream_dispatcher_host_->BindRequest(std::move(request));
+}
+#endif
+
 void RenderFrameHostImpl::BindMediaInterfaceFactoryRequest(
     media::mojom::InterfaceFactoryRequest request) {
   DCHECK(!media_interface_proxy_);

content/browser/frame_host/render_frame_host_impl.h

@@ -46,6 +46,7 @@
 #include "content/common/image_downloader/image_downloader.mojom.h"
 #include "content/common/input/input_handler.mojom.h"
 #include "content/common/navigation_params.mojom.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/javascript_dialog_type.h"
@@ -141,6 +142,10 @@ struct RequestNavigationParams;
 struct ResourceTimingInfo;
 struct SubresourceLoaderParams;
 
+#if BUILDFLAG(ENABLE_WEBRTC)
+class MediaStreamDispatcherHost;
+#endif
+
 class CONTENT_EXPORT RenderFrameHostImpl
     : public RenderFrameHost,
       public base::SupportsUserData,
@@ -986,6 +991,12 @@ class CONTENT_EXPORT RenderFrameHostImpl
   void CreateAudioOutputStreamFactory(
       mojom::RendererAudioOutputStreamFactoryRequest request);
 
+#if BUILDFLAG(ENABLE_WEBRTC)
+  void CreateMediaStreamDispatcherHost(
+      MediaStreamManager* media_stream_manager,
+      mojom::MediaStreamDispatcherHostRequest request);
+#endif
+
   void BindMediaInterfaceFactoryRequest(
       media::mojom::InterfaceFactoryRequest request);
 
@@ -1323,6 +1334,11 @@ class CONTENT_EXPORT RenderFrameHostImpl
   UniqueAudioInputStreamFactoryPtr audio_input_stream_factory_;
   UniqueAudioOutputStreamFactoryPtr audio_output_stream_factory_;
 
+#if BUILDFLAG(ENABLE_WEBRTC)
+  std::unique_ptr<MediaStreamDispatcherHost, BrowserThread::DeleteOnIOThread>
+      media_stream_dispatcher_host_;
+#endif
+
   // Hosts media::mojom::InterfaceFactory for the RenderFrame and forwards
   // media::mojom::InterfaceFactory calls to the remote "media" service.
   std::unique_ptr<MediaInterfaceProxy> media_interface_proxy_;

content/browser/renderer_host/media/media_stream_dispatcher_host.cc

@@ -34,8 +34,10 @@ void BindMediaStreamDeviceObserverRequest(
 
 MediaStreamDispatcherHost::MediaStreamDispatcherHost(
     int render_process_id,
+    int render_frame_id,
     MediaStreamManager* media_stream_manager)
     : render_process_id_(render_process_id),
+      render_frame_id_(render_frame_id),
       media_stream_manager_(media_stream_manager),
       salt_and_origin_callback_(
           base::BindRepeating(&GetMediaDeviceSaltAndOrigin)),
@@ -62,79 +64,64 @@ void MediaStreamDispatcherHost::BindRequest(
 }
 
 void MediaStreamDispatcherHost::OnDeviceStopped(
-    int render_frame_id,
     const std::string& label,
     const MediaStreamDevice& device) {
-  DVLOG(1) << __func__ << " label=" << label << " type=" << device.type
-           << " device_id=" << device.id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  GetMediaStreamDeviceObserverForFrame(render_frame_id)
-      ->OnDeviceStopped(label, device);
+  GetMediaStreamDeviceObserver()->OnDeviceStopped(label, device);
 }
 
-mojom::MediaStreamDeviceObserver*
-MediaStreamDispatcherHost::GetMediaStreamDeviceObserverForFrame(
-    int render_frame_id) {
+const mojom::MediaStreamDeviceObserverPtr&
+MediaStreamDispatcherHost::GetMediaStreamDeviceObserver() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  auto it = observers_.find(render_frame_id);
-  if (it != observers_.end())
-    return it->second.get();
+  if (media_stream_device_observer_)
+    return media_stream_device_observer_;
 
   mojom::MediaStreamDeviceObserverPtr observer;
   auto dispatcher_request = mojo::MakeRequest(&observer);
   observer.set_connection_error_handler(base::BindOnce(
       &MediaStreamDispatcherHost::OnMediaStreamDeviceObserverConnectionError,
-      weak_factory_.GetWeakPtr(), render_frame_id));
+      weak_factory_.GetWeakPtr()));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(&BindMediaStreamDeviceObserverRequest, render_process_id_,
-                     render_frame_id, std::move(dispatcher_request)));
-  observers_[render_frame_id] = std::move(observer);
-
-  return observers_[render_frame_id].get();
+                     render_frame_id_, std::move(dispatcher_request)));
+  media_stream_device_observer_ = std::move(observer);
+  return media_stream_device_observer_;
 }
 
-void MediaStreamDispatcherHost::OnMediaStreamDeviceObserverConnectionError(
-    int render_frame_id) {
+void MediaStreamDispatcherHost::OnMediaStreamDeviceObserverConnectionError() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  observers_.erase(render_frame_id);
+  media_stream_device_observer_.reset();
 }
 
 void MediaStreamDispatcherHost::CancelAllRequests() {
   if (!bindings_.empty())
     return;
 
-  media_stream_manager_->CancelAllRequests(render_process_id_);
+  media_stream_manager_->CancelAllRequests(render_process_id_,
+                                           render_frame_id_);
 }
 
 void MediaStreamDispatcherHost::GenerateStream(
-    int32_t render_frame_id,
     int32_t page_request_id,
     const StreamControls& controls,
     bool user_gesture,
     GenerateStreamCallback callback) {
-  DVLOG(1) << __func__ << " render_frame_id=" << render_frame_id
-           << " page_request_id=" << page_request_id
-           << " audio=" << controls.audio.requested
-           << " video=" << controls.video.requested
-           << " user_gesture=" << user_gesture;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI).get(), FROM_HERE,
       base::BindOnce(salt_and_origin_callback_, render_process_id_,
-                     render_frame_id),
+                     render_frame_id_),
       base::BindOnce(&MediaStreamDispatcherHost::DoGenerateStream,
-                     weak_factory_.GetWeakPtr(), render_frame_id,
-                     page_request_id, controls, user_gesture,
-                     base::Passed(&callback)));
+                     weak_factory_.GetWeakPtr(), page_request_id, controls,
+                     user_gesture, base::Passed(&callback)));
 }
 
 void MediaStreamDispatcherHost::DoGenerateStream(
-    int32_t render_frame_id,
     int32_t page_request_id,
     const StreamControls& controls,
     bool user_gesture,
@@ -150,56 +137,44 @@ void MediaStreamDispatcherHost::DoGenerateStream(
   }
 
   media_stream_manager_->GenerateStream(
-      render_process_id_, render_frame_id, salt_and_origin.first,
+      render_process_id_, render_frame_id_, salt_and_origin.first,
       page_request_id, controls, salt_and_origin.second, user_gesture,
       std::move(callback),
       base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
                           weak_factory_.GetWeakPtr()));
 }
 
-void MediaStreamDispatcherHost::CancelRequest(int render_frame_id,
-                                              int page_request_id) {
-  DVLOG(1) << __func__ << " render_frame_id=" << render_frame_id
-           << " page_request_id=" << page_request_id;
+void MediaStreamDispatcherHost::CancelRequest(int page_request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  media_stream_manager_->CancelRequest(render_process_id_, render_frame_id,
+  media_stream_manager_->CancelRequest(render_process_id_, render_frame_id_,
                                        page_request_id);
 }
 
-void MediaStreamDispatcherHost::StopStreamDevice(int32_t render_frame_id,
-                                                 const std::string& device_id,
+void MediaStreamDispatcherHost::StopStreamDevice(const std::string& device_id,
                                                  int32_t session_id) {
-  DVLOG(1) << __func__ << " render_frame_id=" << render_frame_id
-           << " device_id=" << device_id << " session_id=" << session_id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  media_stream_manager_->StopStreamDevice(render_process_id_, render_frame_id,
+  media_stream_manager_->StopStreamDevice(render_process_id_, render_frame_id_,
                                           device_id, session_id);
 }
 
-void MediaStreamDispatcherHost::OpenDevice(int32_t render_frame_id,
-                                           int32_t page_request_id,
+void MediaStreamDispatcherHost::OpenDevice(int32_t page_request_id,
                                            const std::string& device_id,
                                            MediaStreamType type,
                                            OpenDeviceCallback callback) {
-  DVLOG(1) << __func__ << " render_frame_id=" << render_frame_id
-           << " page_request_id=" << page_request_id
-           << " device_id=" << device_id << " type=" << type;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI).get(), FROM_HERE,
       base::BindOnce(salt_and_origin_callback_, render_process_id_,
-                     render_frame_id),
+                     render_frame_id_),
       base::BindOnce(&MediaStreamDispatcherHost::DoOpenDevice,
-                     weak_factory_.GetWeakPtr(), render_frame_id,
-                     page_request_id, device_id, type,
-                     base::Passed(&callback)));
+                     weak_factory_.GetWeakPtr(), page_request_id, device_id,
+                     type, base::Passed(&callback)));
 }
 
 void MediaStreamDispatcherHost::DoOpenDevice(
-    int32_t render_frame_id,
     int32_t page_request_id,
     const std::string& device_id,
     MediaStreamType type,
@@ -214,15 +189,14 @@ void MediaStreamDispatcherHost::DoOpenDevice(
   }
 
   media_stream_manager_->OpenDevice(
-      render_process_id_, render_frame_id, salt_and_origin.first,
+      render_process_id_, render_frame_id_, salt_and_origin.first,
       page_request_id, device_id, type, salt_and_origin.second,
       std::move(callback),
       base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
                           weak_factory_.GetWeakPtr()));
 }
 
 void MediaStreamDispatcherHost::CloseDevice(const std::string& label) {
-  DVLOG(1) << __func__ << " label= " << label;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->CancelRequest(label);
@@ -231,16 +205,13 @@ void MediaStreamDispatcherHost::CloseDevice(const std::string& label) {
 void MediaStreamDispatcherHost::SetCapturingLinkSecured(int32_t session_id,
                                                         MediaStreamType type,
                                                         bool is_secure) {
-  DVLOG(1) << __func__ << " session_id=" << session_id << " type=" << type
-           << " is_secure=" << is_secure;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->SetCapturingLinkSecured(render_process_id_, session_id,
                                                  type, is_secure);
 }
 
 void MediaStreamDispatcherHost::OnStreamStarted(const std::string& label) {
-  DVLOG(1) << __func__ << " label= " << label;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->OnStreamStarted(label);

content/browser/renderer_host/media/media_stream_dispatcher_host.h

@@ -32,6 +32,7 @@ class CONTENT_EXPORT MediaStreamDispatcherHost
     : public mojom::MediaStreamDispatcherHost {
  public:
   MediaStreamDispatcherHost(int render_process_id,
+                            int render_frame_id,
                             MediaStreamManager* media_stream_manager);
   ~MediaStreamDispatcherHost() override;
 
@@ -42,31 +43,26 @@ class CONTENT_EXPORT MediaStreamDispatcherHost
     salt_and_origin_callback_ = std::move(callback);
   }
   void SetMediaStreamDeviceObserverForTesting(
-      int render_frame_id,
       mojom::MediaStreamDeviceObserverPtr observer) {
-    observers_[render_frame_id] = std::move(observer);
+    media_stream_device_observer_ = std::move(observer);
   }
 
  private:
   friend class MockMediaStreamDispatcherHost;
 
-  mojom::MediaStreamDeviceObserver* GetMediaStreamDeviceObserverForFrame(
-      int render_frame_id);
-  void OnMediaStreamDeviceObserverConnectionError(int render_frame_id);
+  const mojom::MediaStreamDeviceObserverPtr& GetMediaStreamDeviceObserver();
+  void OnMediaStreamDeviceObserverConnectionError();
   void CancelAllRequests();
 
   // mojom::MediaStreamDispatcherHost implementation
-  void GenerateStream(int32_t render_frame_id,
-                      int32_t request_id,
+  void GenerateStream(int32_t request_id,
                       const StreamControls& controls,
                       bool user_gesture,
                       GenerateStreamCallback callback) override;
-  void CancelRequest(int32_t render_frame_id, int32_t request_id) override;
-  void StopStreamDevice(int32_t render_frame_id,
-                        const std::string& device_id,
+  void CancelRequest(int32_t request_id) override;
+  void StopStreamDevice(const std::string& device_id,
                         int32_t session_id) override;
-  void OpenDevice(int32_t render_frame_id,
-                  int32_t request_id,
+  void OpenDevice(int32_t request_id,
                   const std::string& device_id,
                   MediaStreamType type,
                   OpenDeviceCallback callback) override;
@@ -77,26 +73,24 @@ class CONTENT_EXPORT MediaStreamDispatcherHost
   void OnStreamStarted(const std::string& label) override;
 
   void DoGenerateStream(
-      int32_t render_frame_id,
       int32_t request_id,
       const StreamControls& controls,
       bool user_gesture,
       GenerateStreamCallback callback,
       const std::pair<std::string, url::Origin>& salt_and_origin);
-  void DoOpenDevice(int32_t render_frame_id,
-                    int32_t request_id,
+  void DoOpenDevice(int32_t request_id,
                     const std::string& device_id,
                     MediaStreamType type,
                     OpenDeviceCallback callback,
                     const std::pair<std::string, url::Origin>& salt_and_origin);
 
-  void OnDeviceStopped(int render_frame_id,
-                       const std::string& label,
+  void OnDeviceStopped(const std::string& label,
                        const MediaStreamDevice& device);
 
   const int render_process_id_;
+  const int render_frame_id_;
   MediaStreamManager* media_stream_manager_;
-  std::map<int, mojom::MediaStreamDeviceObserverPtr> observers_;
+  mojom::MediaStreamDeviceObserverPtr media_stream_device_observer_;
   mojo::BindingSet<mojom::MediaStreamDispatcherHost> bindings_;
   MediaDeviceSaltAndOriginCallback salt_and_origin_callback_;