diff --git a/content/browser/frame_host/render_frame_host_impl.cc b/content/browser/frame_host/render_frame_host_impl.cc
index e6f29c735c66b1..91688d2183be6c 100644
--- a/content/browser/frame_host/render_frame_host_impl.cc
+++ b/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_);
diff --git a/content/browser/frame_host/render_frame_host_impl.h b/content/browser/frame_host/render_frame_host_impl.h
index 349d8609b8d8e7..72bfbd138dc3f0 100644
--- a/content/browser/frame_host/render_frame_host_impl.h
+++ b/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_;
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc b/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
index 88a042b46bb762..3b422892830f8a 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
+++ b/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,7 +189,7 @@ 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,
@@ -222,7 +197,6 @@ void MediaStreamDispatcherHost::DoOpenDevice(
 }
 
 void MediaStreamDispatcherHost::CloseDevice(const std::string& label) {
-  DVLOG(1) << __func__ << " label= " << label;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->CancelRequest(label);
@@ -231,8 +205,6 @@ 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,
@@ -240,7 +212,6 @@ void MediaStreamDispatcherHost::SetCapturingLinkSecured(int32_t session_id,
 }
 
 void MediaStreamDispatcherHost::OnStreamStarted(const std::string& label) {
-  DVLOG(1) << __func__ << " label= " << label;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   media_stream_manager_->OnStreamStarted(label);
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host.h b/content/browser/renderer_host/media/media_stream_dispatcher_host.h
index 0e802c2563f7cb..fecd1b184f7479 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host.h
+++ b/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_;
 
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc b/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
index 33a9a5830c1209..4c0d08663a378f 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
+++ b/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc
@@ -33,7 +33,7 @@
 #include "media/audio/mock_audio_manager.h"
 #include "media/audio/test_audio_thread.h"
 #include "media/base/media_switches.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ -79,11 +79,12 @@ void AudioInputDevicesEnumerated(base::Closure quit_closure,
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public mojom::MediaStreamDeviceObserver {
  public:
-  MockMediaStreamDispatcherHost(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      MediaStreamManager* manager)
-      : MediaStreamDispatcherHost(kProcessId, manager),
-        task_runner_(task_runner) {}
+  MockMediaStreamDispatcherHost(int render_process_id,
+                                int render_frame_id,
+                                MediaStreamManager* manager)
+      : MediaStreamDispatcherHost(render_process_id, render_frame_id, manager),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()),
+        binding_(this) {}
   ~MockMediaStreamDispatcherHost() override {}
 
   // A list of mock methods.
@@ -97,32 +98,27 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
   MOCK_METHOD0(OnDeviceOpenSuccess, void());
 
   // Accessor to private functions.
-  void OnGenerateStream(int render_frame_id,
-                        int page_request_id,
+  void OnGenerateStream(int page_request_id,
                         const StreamControls& controls,
                         const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::GenerateStream(
-        render_frame_id, page_request_id, controls, false,
+        page_request_id, controls, false,
         base::BindOnce(&MockMediaStreamDispatcherHost::OnStreamGenerated,
                        base::Unretained(this), page_request_id));
   }
 
-  void OnStopStreamDevice(int render_frame_id,
-                          const std::string& device_id,
-                          int session_id) {
-    MediaStreamDispatcherHost::StopStreamDevice(render_frame_id, device_id,
-                                                session_id);
+  void OnStopStreamDevice(const std::string& device_id, int session_id) {
+    MediaStreamDispatcherHost::StopStreamDevice(device_id, session_id);
   }
 
-  void OnOpenDevice(int render_frame_id,
-                    int page_request_id,
+  void OnOpenDevice(int page_request_id,
                     const std::string& device_id,
                     MediaStreamType type,
                     const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OpenDevice(
-        render_frame_id, page_request_id, device_id, type,
+        page_request_id, device_id, type,
         base::BindOnce(&MockMediaStreamDispatcherHost::OnDeviceOpened,
                        base::Unretained(this)));
   }
@@ -139,7 +135,7 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
 
   mojom::MediaStreamDeviceObserverPtr CreateInterfacePtrAndBind() {
     mojom::MediaStreamDeviceObserverPtr observer;
-    bindings_.AddBinding(this, mojo::MakeRequest(&observer));
+    binding_.Bind(mojo::MakeRequest(&observer));
     return observer;
   }
 
@@ -210,9 +206,9 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
     }
   }
 
-  mojo::BindingSet<mojom::MediaStreamDeviceObserver> bindings_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::queue<base::Closure> quit_closures_;
+  mojo::Binding<mojom::MediaStreamDeviceObserver> binding_;
 };
 
 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
@@ -251,14 +247,12 @@ class MediaStreamDispatcherHostTest : public testing::Test {
         std::move(mock_video_capture_provider));
 
     host_ = std::make_unique<MockMediaStreamDispatcherHost>(
-        base::ThreadTaskRunnerHandle::Get(), media_stream_manager_.get());
+        kProcessId, kRenderId, media_stream_manager_.get());
     host_->set_salt_and_origin_callback_for_testing(
         base::BindRepeating(&MediaStreamDispatcherHostTest::GetSaltAndOrigin,
                             base::Unretained(this)));
-    mojom::MediaStreamDeviceObserverPtr observer =
-        host_->CreateInterfacePtrAndBind();
-    host_->SetMediaStreamDeviceObserverForTesting(kRenderId,
-                                                  std::move(observer));
+    host_->SetMediaStreamDeviceObserverForTesting(
+        host_->CreateInterfacePtrAndBind());
 
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::InitializeForTesting();
@@ -313,6 +307,11 @@ class MediaStreamDispatcherHostTest : public testing::Test {
 
   void TearDown() override { host_.reset(); }
 
+  std::pair<std::string, url::Origin> GetSaltAndOrigin(int /* process_id */,
+                                                       int /* frame_id */) {
+    return std::make_pair(browser_context_->GetMediaDeviceIDSalt(), origin_);
+  }
+
  protected:
   std::unique_ptr<FakeMediaStreamUIProxy> CreateMockUI(bool expect_started) {
     std::unique_ptr<MockMediaStreamUIProxy> fake_ui =
@@ -328,8 +327,7 @@ class MediaStreamDispatcherHostTest : public testing::Test {
                    base::Unretained(this), expect_started));
   }
 
-  void GenerateStreamAndWaitForResult(int render_frame_id,
-                                      int page_request_id,
+  void GenerateStreamAndWaitForResult(int page_request_id,
                                       const StreamControls& controls) {
     base::RunLoop run_loop;
     int expected_audio_array_size =
@@ -340,8 +338,7 @@ class MediaStreamDispatcherHostTest : public testing::Test {
     EXPECT_CALL(*host_, OnStreamGenerationSuccess(page_request_id,
                                                   expected_audio_array_size,
                                                   expected_video_array_size));
-    host_->OnGenerateStream(render_frame_id, page_request_id, controls,
-                            run_loop.QuitClosure());
+    host_->OnGenerateStream(page_request_id, controls, run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->audio_devices_));
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
@@ -350,37 +347,34 @@ class MediaStreamDispatcherHostTest : public testing::Test {
   }
 
   void GenerateStreamAndWaitForFailure(
-      int render_frame_id,
       int page_request_id,
       const StreamControls& controls,
       MediaStreamRequestResult expected_result) {
       base::RunLoop run_loop;
       EXPECT_CALL(*host_,
                   OnStreamGenerationFailure(page_request_id, expected_result));
-      host_->OnGenerateStream(render_frame_id, page_request_id, controls,
+      host_->OnGenerateStream(page_request_id, controls,
                               run_loop.QuitClosure());
       run_loop.Run();
   }
 
-  void OpenVideoDeviceAndWaitForResult(int render_frame_id,
-                                       int page_request_id,
+  void OpenVideoDeviceAndWaitForResult(int page_request_id,
                                        const std::string& device_id) {
     EXPECT_CALL(*host_, OnDeviceOpenSuccess());
     base::RunLoop run_loop;
-    host_->OnOpenDevice(render_frame_id, page_request_id, device_id,
-                        MEDIA_DEVICE_VIDEO_CAPTURE, run_loop.QuitClosure());
+    host_->OnOpenDevice(page_request_id, device_id, MEDIA_DEVICE_VIDEO_CAPTURE,
+                        run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
-  void OpenVideoDeviceAndWaitForFailure(int render_frame_id,
-                                        int page_request_id,
+  void OpenVideoDeviceAndWaitForFailure(int page_request_id,
                                         const std::string& device_id) {
     EXPECT_CALL(*host_, OnDeviceOpenSuccess()).Times(0);
     base::RunLoop run_loop;
-    host_->OnOpenDevice(render_frame_id, page_request_id, device_id,
-                        MEDIA_DEVICE_VIDEO_CAPTURE, run_loop.QuitClosure());
+    host_->OnOpenDevice(page_request_id, device_id, MEDIA_DEVICE_VIDEO_CAPTURE,
+                        run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_FALSE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
@@ -431,11 +425,6 @@ class MediaStreamDispatcherHostTest : public testing::Test {
     return true;
   }
 
-  std::pair<std::string, url::Origin> GetSaltAndOrigin(int /* process_id */,
-                                                       int /* frame_id */) {
-    return std::make_pair(browser_context_->GetMediaDeviceIDSalt(), origin_);
-  }
-
   std::unique_ptr<MockMediaStreamDispatcherHost> host_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   TestBrowserThreadBundle thread_bundle_;
@@ -452,7 +441,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ -462,7 +451,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioOnly) {
   StreamControls controls(true, false);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 0u);
@@ -474,7 +463,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioOnly) {
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithNothing) {
   StreamControls controls(false, false);
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
+  GenerateStreamAndWaitForFailure(kPageRequestId, controls,
                                   MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN);
 }
 
@@ -482,7 +471,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioAndVideo) {
   StreamControls controls(true, true);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ -500,7 +489,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithDepthVideo) {
   controls.video.device_id = source_id;
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   // We specified the generation and expect to get
   // one audio and one depth video stream.
@@ -525,7 +514,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
 
   // Generate first stream.
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
@@ -535,7 +524,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
   const int session_id1 = host_->video_devices_.front().session_id;
 
   // Generate second stream.
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId + 1, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId + 1, controls);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
@@ -549,12 +538,12 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
 }
 
 TEST_F(MediaStreamDispatcherHostTest,
-       GenerateStreamAndOpenDeviceFromSameRenderId) {
+       GenerateStreamAndOpenDeviceFromSameRenderFrame) {
   SetupFakeUI(true);
   StreamControls controls(false, true);
 
   // Generate first stream.
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ -563,7 +552,7 @@ TEST_F(MediaStreamDispatcherHostTest,
   const int session_id1 = host_->video_devices_.front().session_id;
 
   // Generate second stream.
-  OpenVideoDeviceAndWaitForResult(kRenderId, kPageRequestId, device_id1);
+  OpenVideoDeviceAndWaitForResult(kPageRequestId, device_id1);
 
   const std::string device_id2 = host_->opened_device_.id;
   const int session_id2 = host_->opened_device_.session_id;
@@ -581,7 +570,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsDifferentRenderId) {
 
   // Generate first stream.
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
@@ -591,11 +580,15 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsDifferentRenderId) {
   const int session_id1 = host_->video_devices_.front().session_id;
 
   // Generate second stream from another render frame.
-  mojom::MediaStreamDeviceObserverPtr observer =
-      host_->CreateInterfacePtrAndBind();
-  host_->SetMediaStreamDeviceObserverForTesting(kRenderId + 1,
-                                                std::move(observer));
-  GenerateStreamAndWaitForResult(kRenderId + 1, kPageRequestId + 1, controls);
+  host_ = std::make_unique<MockMediaStreamDispatcherHost>(
+      kProcessId, kRenderId + 1, media_stream_manager_.get());
+  host_->set_salt_and_origin_callback_for_testing(
+      base::BindRepeating(&MediaStreamDispatcherHostTest::GetSaltAndOrigin,
+                          base::Unretained(this)));
+  host_->SetMediaStreamDeviceObserverForTesting(
+      host_->CreateInterfacePtrAndBind());
+
+  GenerateStreamAndWaitForResult(kPageRequestId + 1, controls);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
@@ -625,9 +618,8 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithoutWaiting) {
   }
   base::RunLoop run_loop1;
   base::RunLoop run_loop2;
-  host_->OnGenerateStream(kRenderId, kPageRequestId, controls,
-                          run_loop1.QuitClosure());
-  host_->OnGenerateStream(kRenderId, kPageRequestId + 1, controls,
+  host_->OnGenerateStream(kPageRequestId, controls, run_loop1.QuitClosure());
+  host_->OnGenerateStream(kPageRequestId + 1, controls,
                           run_loop2.QuitClosure());
 
   run_loop1.Run();
@@ -650,7 +642,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithSourceId) {
     controls.audio.device_id = source_id;
 
     SetupFakeUI(true);
-    GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+    GenerateStreamAndWaitForResult(kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].id, source_id);
   }
 
@@ -661,7 +653,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithSourceId) {
     StreamControls controls(true, true);
     controls.video.device_id = source_id;
 
-    GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+    GenerateStreamAndWaitForResult(kPageRequestId, controls);
     EXPECT_EQ(host_->video_devices_[0].id, source_id);
   }
 }
@@ -671,7 +663,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithInvalidVideoSourceId) {
   StreamControls controls(true, true);
   controls.video.device_id = "invalid source id";
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
+  GenerateStreamAndWaitForFailure(kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
@@ -680,7 +672,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithInvalidAudioSourceId) {
   StreamControls controls(true, true);
   controls.audio.device_id = "invalid source id";
 
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
+  GenerateStreamAndWaitForFailure(kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
@@ -689,7 +681,7 @@ TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsNoAvailableVideoDevice) {
   StreamControls controls(true, true);
 
   SetupFakeUI(false);
-  GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
+  GenerateStreamAndWaitForFailure(kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
@@ -700,7 +692,7 @@ TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStream) {
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   std::string stream_request_label = host_->label_;
   MediaStreamDevice video_device = host_->video_devices_.front();
@@ -708,12 +700,11 @@ TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStream) {
       stream_request_label).size());
 
   // Open the same device by Pepper.
-  OpenVideoDeviceAndWaitForResult(kRenderId, kPageRequestId, video_device.id);
+  OpenVideoDeviceAndWaitForResult(kPageRequestId, video_device.id);
   std::string open_device_request_label = host_->label_;
 
   // Stop the device in the MediaStream.
-  host_->OnStopStreamDevice(kRenderId, video_device.id,
-                            video_device.session_id);
+  host_->OnStopStreamDevice(video_device.id, video_device.session_id);
 
   EXPECT_EQ(0u, media_stream_manager_->GetDevicesOpenedByRequest(
       stream_request_label).size());
@@ -725,7 +716,7 @@ TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStreamAndRestart) {
   StreamControls controls(true, true);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   std::string request_label1 = host_->label_;
   MediaStreamDevice video_device = host_->video_devices_.front();
@@ -733,12 +724,11 @@ TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStreamAndRestart) {
   EXPECT_EQ(2u, media_stream_manager_->GetDevicesOpenedByRequest(
       request_label1).size());
 
-  host_->OnStopStreamDevice(kRenderId, video_device.id,
-                            video_device.session_id);
+  host_->OnStopStreamDevice(video_device.id, video_device.session_id);
   EXPECT_EQ(1u, media_stream_manager_->GetDevicesOpenedByRequest(
       request_label1).size());
 
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
   std::string request_label2 = host_->label_;
 
   MediaStreamDevices request1_devices =
@@ -759,19 +749,19 @@ TEST_F(MediaStreamDispatcherHostTest,
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
   // Generate a second stream.
   EXPECT_CALL(*host_, OnStreamGenerationSuccess(kPageRequestId + 1, 0, 1));
 
   base::RunLoop run_loop1;
-  host_->OnGenerateStream(kRenderId, kPageRequestId + 1, controls,
+  host_->OnGenerateStream(kPageRequestId + 1, controls,
                           run_loop1.QuitClosure());
 
   // Stop the video stream device from stream 1 while waiting for the
   // second stream to be generated.
-  host_->OnStopStreamDevice(kRenderId, host_->video_devices_[0].id,
+  host_->OnStopStreamDevice(host_->video_devices_[0].id,
                             host_->video_devices_[0].session_id);
   run_loop1.Run();
 
@@ -786,11 +776,11 @@ TEST_F(MediaStreamDispatcherHostTest, CancelPendingStreams) {
   // Create multiple GenerateStream requests.
   size_t streams = 5;
   for (size_t i = 1; i <= streams; ++i) {
-    host_->OnGenerateStream(kRenderId, kPageRequestId + i, controls,
+    host_->OnGenerateStream(kPageRequestId + i, controls,
                             run_loop.QuitClosure());
   }
 
-  media_stream_manager_->CancelAllRequests(kProcessId);
+  media_stream_manager_->CancelAllRequests(kProcessId, kRenderId);
   run_loop.RunUntilIdle();
 }
 
@@ -802,9 +792,9 @@ TEST_F(MediaStreamDispatcherHostTest, StopGeneratedStreams) {
   // Create first group of streams.
   size_t generated_streams = 3;
   for (size_t i = 0; i < generated_streams; ++i)
-    GenerateStreamAndWaitForResult(kRenderId, kPageRequestId + i, controls);
+    GenerateStreamAndWaitForResult(kPageRequestId + i, controls);
 
-  media_stream_manager_->CancelAllRequests(kProcessId);
+  media_stream_manager_->CancelAllRequests(kProcessId, kRenderId);
   base::RunLoop().RunUntilIdle();
 }
 
@@ -823,7 +813,7 @@ TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
       },
       &close_callback));
 
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ -839,7 +829,7 @@ TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
 TEST_F(MediaStreamDispatcherHostTest, VideoDeviceUnplugged) {
   StreamControls controls(true, true);
   SetupFakeUI(true);
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
@@ -861,7 +851,7 @@ TEST_F(MediaStreamDispatcherHostTest, Salt) {
   StreamControls controls(false, true);
 
   // Generate first stream.
-  GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
+  GenerateStreamAndWaitForResult(kPageRequestId, controls);
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   const std::string label1 = host_->label_;
@@ -869,7 +859,7 @@ TEST_F(MediaStreamDispatcherHostTest, Salt) {
   const int session_id1 = host_->video_devices_.front().session_id;
 
   // Generate second stream.
-  OpenVideoDeviceAndWaitForResult(kRenderId, kPageRequestId, device_id1);
+  OpenVideoDeviceAndWaitForResult(kPageRequestId, device_id1);
   const std::string device_id2 = host_->opened_device_.id;
   const int session_id2 = host_->opened_device_.session_id;
   const std::string label2 = host_->label_;
@@ -880,7 +870,7 @@ TEST_F(MediaStreamDispatcherHostTest, Salt) {
   // Reset salt and try to generate third stream with the invalidated device ID.
   browser_context_ = std::make_unique<TestBrowserContext>();
   EXPECT_CALL(*host_, OnDeviceOpenSuccess()).Times(0);
-  OpenVideoDeviceAndWaitForFailure(kRenderId, kPageRequestId, device_id1);
+  OpenVideoDeviceAndWaitForFailure(kPageRequestId, device_id1);
   // Last open device ID and session are from the second stream.
   EXPECT_EQ(session_id2, host_->opened_device_.session_id);
   EXPECT_EQ(device_id2, host_->opened_device_.id);
diff --git a/content/browser/renderer_host/media/media_stream_manager.cc b/content/browser/renderer_host/media/media_stream_manager.cc
index 7c34a2faa9867e..f0557dd5df5af6 100644
--- a/content/browser/renderer_host/media/media_stream_manager.cc
+++ b/content/browser/renderer_host/media/media_stream_manager.cc
@@ -665,11 +665,13 @@ void MediaStreamManager::CancelRequest(const std::string& label) {
   DeleteRequest(label);
 }
 
-void MediaStreamManager::CancelAllRequests(int render_process_id) {
+void MediaStreamManager::CancelAllRequests(int render_process_id,
+                                           int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeviceRequests::iterator request_it = requests_.begin();
   while (request_it != requests_.end()) {
-    if (request_it->second->requesting_process_id != render_process_id) {
+    if (request_it->second->requesting_process_id != render_process_id ||
+        request_it->second->requesting_frame_id != render_frame_id) {
       ++request_it;
       continue;
     }
@@ -862,8 +864,7 @@ void MediaStreamManager::StopRemovedDevice(
       if (device.id == source_id && device.type == stream_type) {
         session_ids.push_back(device.session_id);
         if (request->device_stopped_cb) {
-          request->device_stopped_cb.Run(request->requesting_frame_id,
-                                         labeled_request.first, device);
+          request->device_stopped_cb.Run(labeled_request.first, device);
         }
       }
     }
@@ -1632,8 +1633,7 @@ void MediaStreamManager::StopMediaStreamFromBrowser(const std::string& label) {
   // Notify renderers that the devices in the stream will be stopped.
   if (request->device_stopped_cb) {
     for (const MediaStreamDevice& device : request->devices) {
-      request->device_stopped_cb.Run(request->requesting_frame_id, label,
-                                     device);
+      request->device_stopped_cb.Run(label, device);
     }
   }
 
diff --git a/content/browser/renderer_host/media/media_stream_manager.h b/content/browser/renderer_host/media/media_stream_manager.h
index e74ea1edb024a6..262cd2bda8dce5 100644
--- a/content/browser/renderer_host/media/media_stream_manager.h
+++ b/content/browser/renderer_host/media/media_stream_manager.h
@@ -91,8 +91,7 @@ class CONTENT_EXPORT MediaStreamManager
                               const MediaStreamDevice& device)>;
 
   using DeviceStoppedCallback =
-      base::RepeatingCallback<void(int render_frame_id,
-                                   const std::string& label,
+      base::RepeatingCallback<void(const std::string& label,
                                    const MediaStreamDevice& device)>;
 
   // Callback for testing.
@@ -172,10 +171,11 @@ class CONTENT_EXPORT MediaStreamManager
                      int page_request_id);
 
   // Cancel an open request identified by |label|.
-  virtual void CancelRequest(const std::string& label);
+  void CancelRequest(const std::string& label);
 
-  // Cancel all requests for the given |render_process_id|.
-  void CancelAllRequests(int render_process_id);
+  // Cancel all requests for the given |render_process_id| and
+  // |render_frame_id|.
+  void CancelAllRequests(int render_process_id, int render_frame_id);
 
   // Closes the stream device for a certain render frame. The stream must have
   // been opened by a call to GenerateStream.
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 336f6507372920..86dffea6314bf2 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -109,7 +109,6 @@
 #include "content/browser/renderer_host/file_utilities_host_impl.h"
 #include "content/browser/renderer_host/media/audio_input_renderer_host.h"
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
-#include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/peer_connection_tracker_host.h"
 #include "content/browser/renderer_host/media/render_frame_audio_input_stream_factory.h"
@@ -1918,12 +1917,6 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
       base::CreateSequencedTaskRunnerWithTraits(
           {base::MayBlock(), base::TaskPriority::USER_VISIBLE}));
 
-#if BUILDFLAG(ENABLE_WEBRTC)
-  registry->AddInterface(
-      base::Bind(&RenderProcessHostImpl::CreateMediaStreamDispatcherHost,
-                 base::Unretained(this), media_stream_manager));
-#endif
-
   registry->AddInterface(
       base::Bind(&metrics::CreateSingleSampleMetricsProvider));
 
@@ -4031,17 +4024,6 @@ RenderProcessHost* RenderProcessHostImpl::FindReusableProcessHostForSite(
 }
 
 #if BUILDFLAG(ENABLE_WEBRTC)
-void RenderProcessHostImpl::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(GetID(), media_stream_manager));
-  }
-  media_stream_dispatcher_host_->BindRequest(std::move(request));
-}
-
 void RenderProcessHostImpl::OnRegisterAecDumpConsumer(int id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
diff --git a/content/browser/renderer_host/render_process_host_impl.h b/content/browser/renderer_host/render_process_host_impl.h
index f81189990b1f6e..f33df44748bc2d 100644
--- a/content/browser/renderer_host/render_process_host_impl.h
+++ b/content/browser/renderer_host/render_process_host_impl.h
@@ -86,7 +86,6 @@ class StoragePartition;
 class StoragePartitionImpl;
 
 #if BUILDFLAG(ENABLE_WEBRTC)
-class MediaStreamDispatcherHost;
 class P2PSocketDispatcherHost;
 #endif
 
@@ -715,9 +714,6 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   scoped_refptr<base::SequencedTaskRunner>
       audio_debug_recordings_file_task_runner_;
-
-  std::unique_ptr<MediaStreamDispatcherHost, BrowserThread::DeleteOnIOThread>
-      media_stream_dispatcher_host_;
 #endif
 
   // Forwards messages between WebRTCInternals in the browser process
diff --git a/content/common/media/media_stream.mojom b/content/common/media/media_stream.mojom
index 9f4a3daca6d9ef..54ed205a6352de 100644
--- a/content/common/media/media_stream.mojom
+++ b/content/common/media/media_stream.mojom
@@ -62,25 +62,23 @@ interface MediaStreamDeviceObserver {
   OnDeviceStopped(string label, MediaStreamDevice device);
 };
 
-// Per-process browser-side interface that is used by the renderer process to
+// Per-frame browser-side interface that is used by the renderer process to
 // make media stream requests.
 interface MediaStreamDispatcherHost {
   // Requests a new media stream.
-  GenerateStream(int32 render_frame_id, int32 request_id,
-                 StreamControls controls, bool user_gesture)
+  GenerateStream(int32 request_id, StreamControls controls, bool user_gesture)
       => (MediaStreamRequestResult result, string label,
          array<MediaStreamDevice> audio_devices,
          array<MediaStreamDevice> video_devices);
 
   // Cancels the request for a new media stream or opening a device.
-  CancelRequest(int32 render_frame_id, int32 request_id);
+  CancelRequest(int32 request_id);
 
   // Closes a stream device that has been opened by GenerateStream.
-  StopStreamDevice(int32 render_frame_id, string device_id, int32 session_id);
+  StopStreamDevice(string device_id, int32 session_id);
 
   // Opens a device identified by |device_id|.
-  OpenDevice(int32 render_frame_id, int32 request_id, string device_id,
-             MediaStreamType type)
+  OpenDevice(int32 request_id, string device_id, MediaStreamType type)
       => (bool success, string label, MediaStreamDevice device);
 
   // Cancels an open request identified by |label|.
diff --git a/content/public/app/mojo/content_browser_manifest.json b/content/public/app/mojo/content_browser_manifest.json
index 233b3ec0ac7925..b32509c8601886 100644
--- a/content/public/app/mojo/content_browser_manifest.json
+++ b/content/public/app/mojo/content_browser_manifest.json
@@ -41,7 +41,6 @@
           "content::mojom::FieldTrialRecorder",
           "content::mojom::FileUtilitiesHost",
           "content::mojom::FrameSinkProvider",
-          "content::mojom::MediaStreamDispatcherHost",
           "content::mojom::MemoryCoordinatorHandle",
           "content::mojom::PushMessaging",
           "content::mojom::RendererHost",
@@ -150,6 +149,7 @@
           // InputInjector is only exposed when gpu benchmarking is enabled.
           "content::mojom::InputInjector",
 
+          "content::mojom::MediaStreamDispatcherHost",
           "content::mojom::RendererAudioInputStreamFactory",
           "content::mojom::RendererAudioOutputStreamFactory",
           "content::mojom::SharedWorkerConnector",
diff --git a/content/renderer/media/media_stream_device_observer_unittest.cc b/content/renderer/media/media_stream_device_observer_unittest.cc
index f82a56a11b7138..65acaf593f4130 100644
--- a/content/renderer/media/media_stream_device_observer_unittest.cc
+++ b/content/renderer/media/media_stream_device_observer_unittest.cc
@@ -43,7 +43,6 @@ class MediaStreamDeviceObserverTest : public ::testing::Test {
 };
 
 TEST_F(MediaStreamDeviceObserverTest, GetNonScreenCaptureDevices) {
-  const int kRenderId = 3;
   const int kRequestId1 = 5;
   const int kRequestId2 = 7;
 
@@ -52,7 +51,7 @@ TEST_F(MediaStreamDeviceObserverTest, GetNonScreenCaptureDevices) {
   // OpenDevice request 1
   base::RunLoop run_loop1;
   mock_dispatcher_host_.OpenDevice(
-      kRenderId, kRequestId1, "device_path", MEDIA_DEVICE_VIDEO_CAPTURE,
+      kRequestId1, "device_path", MEDIA_DEVICE_VIDEO_CAPTURE,
       base::BindOnce(&MediaStreamDeviceObserverTest::OnDeviceOpened,
                      base::Unretained(this), run_loop1.QuitClosure()));
   run_loop1.Run();
@@ -61,7 +60,7 @@ TEST_F(MediaStreamDeviceObserverTest, GetNonScreenCaptureDevices) {
   // OpenDevice request 2
   base::RunLoop run_loop2;
   mock_dispatcher_host_.OpenDevice(
-      kRenderId, kRequestId2, "screen_capture", MEDIA_DESKTOP_VIDEO_CAPTURE,
+      kRequestId2, "screen_capture", MEDIA_DESKTOP_VIDEO_CAPTURE,
       base::BindOnce(&MediaStreamDeviceObserverTest::OnDeviceOpened,
                      base::Unretained(this), run_loop2.QuitClosure()));
   run_loop2.Run();
diff --git a/content/renderer/media/media_stream_video_capturer_source.cc b/content/renderer/media/media_stream_video_capturer_source.cc
index a148e7ac75c8ed..5e1adcea627aaf 100644
--- a/content/renderer/media/media_stream_video_capturer_source.cc
+++ b/content/renderer/media/media_stream_video_capturer_source.cc
@@ -13,9 +13,8 @@
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/child/child_thread_impl.h"
 #include "content/public/common/media_stream_request.h"
-#include "content/public/common/service_names.mojom.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/render_thread_impl.h"
@@ -23,7 +22,8 @@
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/capture/video_capturer_source.h"
-#include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace content {
 
@@ -161,7 +161,12 @@ void LocalVideoCapturerSource::OnStateUpdate(VideoCaptureState state) {
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const SourceStoppedCallback& stop_callback,
     std::unique_ptr<media::VideoCapturerSource> source)
-    : dispatcher_host_(nullptr), source_(std::move(source)) {
+    : source_(std::move(source)) {
+  blink::WebLocalFrame* web_frame =
+      blink::WebLocalFrame::FrameForCurrentContext();
+  RenderFrame* render_frame = RenderFrame::FromWebFrame(web_frame);
+  render_frame_id_ =
+      render_frame ? render_frame->GetRoutingID() : MSG_ROUTING_NONE;
   media::VideoCaptureFormats preferred_formats = source_->GetPreferredFormats();
   if (!preferred_formats.empty())
     capture_params_.requested_format = preferred_formats.front();
@@ -169,10 +174,11 @@ MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
 }
 
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
+    int render_frame_id,
     const SourceStoppedCallback& stop_callback,
     const MediaStreamDevice& device,
     const media::VideoCaptureParams& capture_params)
-    : dispatcher_host_(nullptr),
+    : render_frame_id_(render_frame_id),
       source_(new LocalVideoCapturerSource(device.session_id)),
       capture_params_(capture_params) {
   SetStopCallback(stop_callback);
@@ -199,8 +205,11 @@ void MediaStreamVideoCapturerSource::OnHasConsumers(bool has_consumers) {
 
 void MediaStreamVideoCapturerSource::OnCapturingLinkSecured(bool is_secure) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  GetMediaStreamDispatcherHost()->SetCapturingLinkSecured(
-      device().session_id, device().type, is_secure);
+  RenderFrame* render_frame = RenderFrame::FromRoutingID(render_frame_id_);
+  if (!render_frame)
+    return;
+  GetMediaStreamDispatcherHost(render_frame)
+      ->SetCapturingLinkSecured(device().session_id, device().type, is_secure);
 }
 
 void MediaStreamVideoCapturerSource::StartSourceImpl(
@@ -298,11 +307,12 @@ void MediaStreamVideoCapturerSource::OnRunStateChanged(
 }
 
 const mojom::MediaStreamDispatcherHostPtr&
-MediaStreamVideoCapturerSource::GetMediaStreamDispatcherHost() {
+MediaStreamVideoCapturerSource::GetMediaStreamDispatcherHost(
+    RenderFrame* render_frame) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!dispatcher_host_) {
-    ChildThreadImpl::current()->GetConnector()->BindInterface(
-        mojom::kBrowserServiceName, &dispatcher_host_);
+    render_frame->GetRemoteInterfaces()->GetInterface(
+        mojo::MakeRequest(&dispatcher_host_));
   }
   return dispatcher_host_;
 }
diff --git a/content/renderer/media/media_stream_video_capturer_source.h b/content/renderer/media/media_stream_video_capturer_source.h
index 7ff5461cd73c21..b0a486abc87951 100644
--- a/content/renderer/media/media_stream_video_capturer_source.h
+++ b/content/renderer/media/media_stream_video_capturer_source.h
@@ -21,6 +21,8 @@ class VideoCapturerSource;
 
 namespace content {
 
+class RenderFrame;
+
 // Representation of a video stream coming from a camera, owned by Blink as
 // WebMediaStreamSource. Objects of this class are created and live on main
 // Render thread. Objects can be constructed either by indicating a |device| to
@@ -32,6 +34,7 @@ class CONTENT_EXPORT MediaStreamVideoCapturerSource
       const SourceStoppedCallback& stop_callback,
       std::unique_ptr<media::VideoCapturerSource> source);
   MediaStreamVideoCapturerSource(
+      int render_frame_id,
       const SourceStoppedCallback& stop_callback,
       const MediaStreamDevice& device,
       const media::VideoCaptureParams& capture_params);
@@ -62,10 +65,13 @@ class CONTENT_EXPORT MediaStreamVideoCapturerSource
   void OnRunStateChanged(const media::VideoCaptureParams& new_capture_params,
                          bool is_running);
 
-  const mojom::MediaStreamDispatcherHostPtr& GetMediaStreamDispatcherHost();
+  const mojom::MediaStreamDispatcherHostPtr& GetMediaStreamDispatcherHost(
+      RenderFrame* render_frame);
 
   mojom::MediaStreamDispatcherHostPtr dispatcher_host_;
 
+  int render_frame_id_;
+
   // The source that provides video frames.
   const std::unique_ptr<media::VideoCapturerSource> source_;
 
diff --git a/content/renderer/media/mock_mojo_media_stream_dispatcher_host.cc b/content/renderer/media/mock_mojo_media_stream_dispatcher_host.cc
index 34df517779a72b..0ddff48fcf2a2e 100644
--- a/content/renderer/media/mock_mojo_media_stream_dispatcher_host.cc
+++ b/content/renderer/media/mock_mojo_media_stream_dispatcher_host.cc
@@ -21,7 +21,6 @@ MockMojoMediaStreamDispatcherHost::CreateInterfacePtrAndBind() {
 }
 
 void MockMojoMediaStreamDispatcherHost::GenerateStream(
-    int32_t render_frame_id,
     int32_t request_id,
     const StreamControls& controls,
     bool user_gesture,
@@ -61,13 +60,11 @@ void MockMojoMediaStreamDispatcherHost::GenerateStream(
   }
 }
 
-void MockMojoMediaStreamDispatcherHost::CancelRequest(int32_t render_frame_id,
-                                                      int32_t request_id) {
+void MockMojoMediaStreamDispatcherHost::CancelRequest(int32_t request_id) {
   EXPECT_EQ(request_id, request_id_);
 }
 
 void MockMojoMediaStreamDispatcherHost::StopStreamDevice(
-    int32_t render_frame_id,
     const std::string& device_id,
     int32_t session_id) {
   for (const MediaStreamDevice& device : audio_devices_) {
@@ -86,7 +83,6 @@ void MockMojoMediaStreamDispatcherHost::StopStreamDevice(
 }
 
 void MockMojoMediaStreamDispatcherHost::OpenDevice(
-    int32_t render_frame_id,
     int32_t request_id,
     const std::string& device_id,
     MediaStreamType type,
diff --git a/content/renderer/media/mock_mojo_media_stream_dispatcher_host.h b/content/renderer/media/mock_mojo_media_stream_dispatcher_host.h
index 283b476b4f6355..089f65a9fd2f6e 100644
--- a/content/renderer/media/mock_mojo_media_stream_dispatcher_host.h
+++ b/content/renderer/media/mock_mojo_media_stream_dispatcher_host.h
@@ -24,17 +24,14 @@ class MockMojoMediaStreamDispatcherHost
 
   mojom::MediaStreamDispatcherHostPtr CreateInterfacePtrAndBind();
 
-  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;
diff --git a/content/renderer/media/user_media_processor.cc b/content/renderer/media/user_media_processor.cc
index c84fbc20b15088..38d3382d4da2ac 100644
--- a/content/renderer/media/user_media_processor.cc
+++ b/content/renderer/media/user_media_processor.cc
@@ -17,9 +17,7 @@
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/child/child_thread_impl.h"
 #include "content/common/media/media_stream_controls.h"
-#include "content/public/common/service_names.mojom.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/local_media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
@@ -38,7 +36,7 @@
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "media/base/audio_parameters.h"
 #include "media/capture/video_capture_types.h"
-#include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
@@ -328,8 +326,7 @@ UserMediaProcessor::UserMediaProcessor(
     : dependency_factory_(dependency_factory),
       media_stream_device_observer_(std::move(media_stream_device_observer)),
       media_devices_dispatcher_cb_(std::move(media_devices_dispatcher_cb)),
-      render_frame_id_(render_frame ? render_frame->GetRoutingID()
-                                    : MSG_ROUTING_NONE),
+      render_frame_(render_frame),
       weak_factory_(this) {
   DCHECK(dependency_factory_);
   DCHECK(media_stream_device_observer_.get());
@@ -567,7 +564,7 @@ void UserMediaProcessor::GenerateStreamForCurrentRequestInfo() {
 
   // The browser replies to this request by invoking OnStreamGenerated().
   GetMediaStreamDispatcherHost()->GenerateStream(
-      render_frame_id_, current_request_info_->request_id(),
+      current_request_info_->request_id(),
       *current_request_info_->stream_controls(),
       current_request_info_->is_processing_user_gesture(),
       base::BindOnce(&UserMediaProcessor::OnStreamGenerated,
@@ -636,15 +633,13 @@ void UserMediaProcessor::OnStreamGeneratedForCancelledRequest(
   // Only stop the device if the device is not used in another MediaStream.
   for (auto it = audio_devices.begin(); it != audio_devices.end(); ++it) {
     if (!FindLocalSource(*it)) {
-      GetMediaStreamDispatcherHost()->StopStreamDevice(render_frame_id_, it->id,
-                                                       it->session_id);
+      GetMediaStreamDispatcherHost()->StopStreamDevice(it->id, it->session_id);
     }
   }
 
   for (auto it = video_devices.begin(); it != video_devices.end(); ++it) {
     if (!FindLocalSource(*it)) {
-      GetMediaStreamDispatcherHost()->StopStreamDevice(render_frame_id_, it->id,
-                                                       it->session_id);
+      GetMediaStreamDispatcherHost()->StopStreamDevice(it->id, it->session_id);
     }
   }
 }
@@ -803,7 +798,7 @@ MediaStreamAudioSource* UserMediaProcessor::CreateAudioSource(
           audio_processing_properties)) {
     *has_sw_echo_cancellation = false;
     return new LocalMediaStreamAudioSource(
-        render_frame_id_, device, stream_controls->hotword_enabled,
+        render_frame_->GetRoutingID(), device, stream_controls->hotword_enabled,
         stream_controls->disable_local_echo, source_ready);
   }
 
@@ -812,7 +807,7 @@ MediaStreamAudioSource* UserMediaProcessor::CreateAudioSource(
   *has_sw_echo_cancellation =
       audio_processing_properties.enable_sw_echo_cancellation;
   return new ProcessedLocalAudioSource(
-      render_frame_id_, device, stream_controls->hotword_enabled,
+      render_frame_->GetRoutingID(), device, stream_controls->hotword_enabled,
       stream_controls->disable_local_echo, audio_processing_properties,
       source_ready, dependency_factory_);
 }
@@ -825,7 +820,7 @@ MediaStreamVideoSource* UserMediaProcessor::CreateVideoSource(
   DCHECK(current_request_info_->video_capture_settings().HasValue());
 
   return new MediaStreamVideoCapturerSource(
-      stop_callback, device,
+      render_frame_->GetRoutingID(), stop_callback, device,
       current_request_info_->video_capture_settings().capture_params());
 }
 
@@ -1134,7 +1129,7 @@ void UserMediaProcessor::StopAllProcessing() {
       if (current_request_info_->state() ==
           RequestInfo::State::SENT_FOR_GENERATION) {
         GetMediaStreamDispatcherHost()->CancelRequest(
-            render_frame_id_, current_request_info_->request_id());
+            current_request_info_->request_id());
       }
       LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED);
     }
@@ -1162,8 +1157,7 @@ void UserMediaProcessor::OnLocalSourceStopped(
       static_cast<MediaStreamSource*>(source.GetExtraData());
   media_stream_device_observer_->RemoveStreamDevice(source_impl->device());
   GetMediaStreamDispatcherHost()->StopStreamDevice(
-      render_frame_id_, source_impl->device().id,
-      source_impl->device().session_id);
+      source_impl->device().id, source_impl->device().session_id);
 }
 
 void UserMediaProcessor::StopLocalSource(
@@ -1177,8 +1171,7 @@ void UserMediaProcessor::StopLocalSource(
   if (notify_dispatcher) {
     media_stream_device_observer_->RemoveStreamDevice(source_impl->device());
     GetMediaStreamDispatcherHost()->StopStreamDevice(
-        render_frame_id_, source_impl->device().id,
-        source_impl->device().session_id);
+        source_impl->device().id, source_impl->device().session_id);
   }
 
   source_impl->ResetSourceStoppedCallback();
@@ -1188,8 +1181,8 @@ void UserMediaProcessor::StopLocalSource(
 const mojom::MediaStreamDispatcherHostPtr&
 UserMediaProcessor::GetMediaStreamDispatcherHost() {
   if (!dispatcher_host_) {
-    ChildThreadImpl::current()->GetConnector()->BindInterface(
-        mojom::kBrowserServiceName, &dispatcher_host_);
+    render_frame_->GetRemoteInterfaces()->GetInterface(
+        mojo::MakeRequest(&dispatcher_host_));
   }
   return dispatcher_host_;
 }
diff --git a/content/renderer/media/user_media_processor.h b/content/renderer/media/user_media_processor.h
index 975038b3c4e72e..c963cb5696c098 100644
--- a/content/renderer/media/user_media_processor.h
+++ b/content/renderer/media/user_media_processor.h
@@ -284,7 +284,7 @@ class CONTENT_EXPORT UserMediaProcessor
   MediaDevicesDispatcherCallback media_devices_dispatcher_cb_;
   base::OnceClosure request_completed_cb_;
 
-  const int render_frame_id_;
+  RenderFrame* const render_frame_;
 
   SEQUENCE_CHECKER(sequence_checker_);
 
diff --git a/content/renderer/pepper/pepper_media_device_manager.cc b/content/renderer/pepper/pepper_media_device_manager.cc
index 4e3f384798c54a..1c8711c945db04 100644
--- a/content/renderer/pepper/pepper_media_device_manager.cc
+++ b/content/renderer/pepper/pepper_media_device_manager.cc
@@ -10,16 +10,13 @@
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/child/child_thread_impl.h"
 #include "content/public/common/console_message_level.h"
 #include "content/public/common/content_features.h"
-#include "content/public/common/service_names.mojom.h"
 #include "content/renderer/media/media_stream_device_observer.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/media_features.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
-#include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 
 namespace content {
@@ -184,7 +181,7 @@ int PepperMediaDeviceManager::OpenDevice(PP_DeviceType_Dev type,
 
 #if BUILDFLAG(ENABLE_WEBRTC)
   GetMediaStreamDispatcherHost()->OpenDevice(
-      routing_id(), request_id, device_id,
+      request_id, device_id,
       PepperMediaDeviceManager::FromPepperDeviceType(type),
       base::BindOnce(&PepperMediaDeviceManager::OnDeviceOpened, AsWeakPtr(),
                      request_id));
@@ -202,7 +199,7 @@ void PepperMediaDeviceManager::CancelOpenDevice(int request_id) {
   open_callbacks_.erase(request_id);
 
 #if BUILDFLAG(ENABLE_WEBRTC)
-  GetMediaStreamDispatcherHost()->CancelRequest(routing_id(), request_id);
+  GetMediaStreamDispatcherHost()->CancelRequest(request_id);
 #endif
 }
 
@@ -287,8 +284,10 @@ void PepperMediaDeviceManager::DevicesEnumerated(
 const mojom::MediaStreamDispatcherHostPtr&
 PepperMediaDeviceManager::GetMediaStreamDispatcherHost() {
   if (!dispatcher_host_) {
-    ChildThreadImpl::current()->GetConnector()->BindInterface(
-        mojom::kBrowserServiceName, &dispatcher_host_);
+    CHECK(render_frame());
+    CHECK(render_frame()->GetRemoteInterfaces());
+    render_frame()->GetRemoteInterfaces()->GetInterface(
+        mojo::MakeRequest(&dispatcher_host_));
   }
   return dispatcher_host_;
 }