Migrate PeerConnectionTracker and PeerConnectionTrackerHost to Mojo

This is a preliminary step to Onion souping content::PeerConnectionTracker.

The CL migrates both content::PeerConnectionTracker (renderer) and
content::PeerConnectionTrackerHost (browser) classes away from old
IPC mechanism, to use Mojo.

Additionally, the CL removes from:

- PeerConnectionTracker
  * the inheritance from content::RenderThreadObserver, as well as the respective
  overridden methods, namely OnControlMessageReceived().

- PeerConnectionTrackerHost
  * the inheritance from content::BrowserMessageFilter and
    content::BrowserAssociatedInterface, as well as the respective overridden,
    namely OnMessageReceived(), OverrideThreadForMessage(), OnChannelConnected(),
    OnChannelClosing().

It is important to note that PeerConnectionTrackerHost now operates solely
on the UI thread, so the CL removes some threading jumps between UI and IO
threads.

Last, content/common/media/peer_connection_tracker_messages.h (which declares
the macro-based IPC messages) is now gone.

BUG=787254
TBR=jam@chromium.org

Change-Id: I3ce5af1853384146d893da2a34c333aad80f5255
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1831197
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#707672}

content/browser/renderer_host/media/peer_connection_tracker_host.h

@@ -9,48 +9,43 @@
 
 #include "base/macros.h"
 #include "base/power_monitor/power_observer.h"
+#include "base/process/process_handle.h"
 #include "content/common/media/peer_connection_tracker.mojom.h"
-#include "content/public/browser/browser_associated_interface.h"
-#include "content/public/browser/browser_message_filter.h"
-#include "content/public/browser/browser_thread.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
-class ListValue;
+class Value;
 }  // namespace base
 
 namespace content {
 
+class RenderProcessHost;
+
 // This class is the host for PeerConnectionTracker in the browser process
 // managed by RenderProcessHostImpl. It receives PeerConnection events from
 // PeerConnectionTracker as IPC messages that it forwards to WebRTCInternals.
 // It also forwards browser process events to PeerConnectionTracker via IPC.
-class PeerConnectionTrackerHost
-    : public BrowserMessageFilter,
-      public base::PowerObserver,
-      public BrowserAssociatedInterface<mojom::PeerConnectionTrackerHost>,
-      public mojom::PeerConnectionTrackerHost {
+class PeerConnectionTrackerHost : public base::PowerObserver,
+                                  public mojom::PeerConnectionTrackerHost {
  public:
-  explicit PeerConnectionTrackerHost(int render_process_id);
-
-  // content::BrowserMessageFilter override.
-  bool OnMessageReceived(const IPC::Message& message) override;
-  void OverrideThreadForMessage(const IPC::Message& message,
-                                BrowserThread::ID* thread) override;
-  void OnChannelConnected(int32_t peer_pid) override;
-  void OnChannelClosing() override;
+  explicit PeerConnectionTrackerHost(RenderProcessHost* rph);
+  ~PeerConnectionTrackerHost() override;
 
   // base::PowerObserver override.
   void OnSuspend() override;
 
- protected:
-  ~PeerConnectionTrackerHost() override;
+  // These methods call out to mojom::PeerConnectionManager on renderer side.
+  void StartEventLog(int peer_connection_local_id, int output_period_ms);
+  void StopEventLog(int lid);
+  void GetStandardStats();
+  void GetLegacyStats();
 
- private:
-  // Handlers for IPC messages coming from the renderer.
-  void OnAddStandardStats(int lid, const base::ListValue& value);
-  void OnAddLegacyStats(int lid, const base::ListValue& value);
-  void SendOnSuspendOnUIThread();
+  void BindReceiver(
+      mojo::PendingReceiver<mojom::PeerConnectionTrackerHost> pending_receiver);
 
+ private:
   // mojom::PeerConnectionTrackerHost implementation.
   void AddPeerConnection(mojom::PeerConnectionInfoPtr info) override;
   void RemovePeerConnection(int lid) override;
@@ -65,8 +60,13 @@ class PeerConnectionTrackerHost
                     const std::string& audio_constraints,
                     const std::string& video_constraints) override;
   void WebRtcEventLogWrite(int lid, const std::string& output) override;
+  void AddStandardStats(int lid, base::Value value) override;
+  void AddLegacyStats(int lid, base::Value value) override;
 
   int render_process_id_;
+  base::ProcessId peer_pid_;
+  mojo::Receiver<mojom::PeerConnectionTrackerHost> receiver_{this};
+  mojo::Remote<mojom::PeerConnectionManager> tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(PeerConnectionTrackerHost);
 };

content/browser/renderer_host/render_process_host_impl.cc

@@ -142,7 +142,6 @@
 #include "content/common/content_switches_internal.h"
 #include "content/common/frame_messages.h"
 #include "content/common/in_process_child_thread_params.h"
-#include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/common/service_manager/child_connection.h"
 #include "content/common/service_manager/service_manager_connection_impl.h"
@@ -1848,8 +1847,6 @@ void RenderProcessHostImpl::CreateMessageFilters() {
       GetBrowserContext(), storage_partition_impl_, widget_helper_.get());
   AddFilter(render_frame_message_filter_.get());
 
-  peer_connection_tracker_host_ = new PeerConnectionTrackerHost(GetID());
-  AddFilter(peer_connection_tracker_host_.get());
 #if BUILDFLAG(ENABLE_PLUGINS)
   AddFilter(new PepperRendererConnection(GetID()));
 #endif
@@ -1982,6 +1979,15 @@ void RenderProcessHostImpl::CleanupCorbExceptionForPluginUponDestruction() {
   cleanup_corb_exception_for_plugin_upon_destruction_ = true;
 }
 
+PeerConnectionTrackerHost*
+RenderProcessHostImpl::GetPeerConnectionTrackerHost() {
+  if (!peer_connection_tracker_host_) {
+    peer_connection_tracker_host_ =
+        std::make_unique<PeerConnectionTrackerHost>(this);
+  }
+  return peer_connection_tracker_host_.get();
+}
+
 void RenderProcessHostImpl::RegisterMojoInterfaces() {
   auto registry = std::make_unique<service_manager::BinderRegistry>();
 
@@ -2154,6 +2160,11 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
   registry->AddInterface(
       base::BindRepeating(&metrics::CreateSingleSampleMetricsProvider));
 
+  AddUIThreadInterface(
+      registry.get(),
+      base::BindRepeating(&RenderProcessHostImpl::BindPeerConnectionTrackerHost,
+                          base::Unretained(this)));
+
   AddUIThreadInterface(
       registry.get(),
       base::BindRepeating(
@@ -3635,11 +3646,11 @@ RenderProcessHostImpl::StartRtpDump(
 
 void RenderProcessHostImpl::EnableWebRtcEventLogOutput(int lid,
                                                        int output_period_ms) {
-  Send(new PeerConnectionTracker_StartEventLog(lid, output_period_ms));
+  GetPeerConnectionTrackerHost()->StartEventLog(lid, output_period_ms);
 }
 
 void RenderProcessHostImpl::DisableWebRtcEventLogOutput(int lid) {
-  Send(new PeerConnectionTracker_StopEventLog(lid));
+  GetPeerConnectionTrackerHost()->StopEventLog(lid);
 }
 
 IPC::ChannelProxy* RenderProcessHostImpl::GetChannel() {
@@ -4699,6 +4710,11 @@ void RenderProcessHostImpl::CreateMediaStreamTrackMetricsHost(
   media_stream_track_metrics_host_->BindReceiver(std::move(receiver));
 }
 
+void RenderProcessHostImpl::BindPeerConnectionTrackerHost(
+    mojo::PendingReceiver<mojom::PeerConnectionTrackerHost> receiver) {
+  GetPeerConnectionTrackerHost()->BindReceiver(std::move(receiver));
+}
+
 #if BUILDFLAG(ENABLE_MDNS)
 void RenderProcessHostImpl::CreateMdnsResponder(
     mojo::PendingReceiver<network::mojom::MdnsResponder> receiver) {

content/browser/renderer_host/render_process_host_impl.h

@@ -41,6 +41,7 @@
 #include "content/common/associated_interfaces.mojom.h"
 #include "content/common/child_process.mojom.h"
 #include "content/common/content_export.h"
+#include "content/common/media/peer_connection_tracker.mojom.h"
 #include "content/common/media/renderer_audio_output_stream_factory.mojom.h"
 #include "content/common/renderer.mojom.h"
 #include "content/common/renderer_host.mojom.h"
@@ -567,6 +568,8 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   size_t keep_alive_ref_count() const { return keep_alive_ref_count_; }
 
+  PeerConnectionTrackerHost* GetPeerConnectionTrackerHost();
+
  protected:
   // A proxy for our IPC::Channel that lives on the IO thread.
   std::unique_ptr<IPC::ChannelProxy> channel_;
@@ -741,6 +744,9 @@ class CONTENT_EXPORT RenderProcessHostImpl
       mojo::PendingReceiver<blink::mojom::MediaStreamTrackMetricsHost>
           receiver);
 
+  void BindPeerConnectionTrackerHost(
+      mojo::PendingReceiver<mojom::PeerConnectionTrackerHost> receiver);
+
 #if BUILDFLAG(ENABLE_MDNS)
   void CreateMdnsResponder(
       mojo::PendingReceiver<network::mojom::MdnsResponder> receiver);
@@ -976,9 +982,7 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   // Forwards messages between WebRTCInternals in the browser process
   // and PeerConnectionTracker in the renderer process.
-  // It holds a raw pointer to webrtc_eventlog_host_, and therefore should be
-  // defined below it so it is destructed first.
-  scoped_refptr<PeerConnectionTrackerHost> peer_connection_tracker_host_;
+  std::unique_ptr<PeerConnectionTrackerHost> peer_connection_tracker_host_;
 
   // Records the time when the process starts surviving for workers for UMA.
   base::TimeTicks keep_alive_start_time_;

content/browser/webrtc/webrtc_internals_message_handler.cc

@@ -6,8 +6,9 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "content/browser/renderer_host/media/peer_connection_tracker_host.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/webrtc/webrtc_internals.h"
-#include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
@@ -93,7 +94,9 @@ void WebRTCInternalsMessageHandler::OnGetStandardStats(
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->Send(new PeerConnectionTracker_GetStandardStats());
+    auto* render_process_host =
+        static_cast<RenderProcessHostImpl*>(i.GetCurrentValue());
+    render_process_host->GetPeerConnectionTrackerHost()->GetStandardStats();
   }
 }
 
@@ -102,7 +105,9 @@ void WebRTCInternalsMessageHandler::OnGetLegacyStats(
   for (RenderProcessHost::iterator i(
        content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->Send(new PeerConnectionTracker_GetLegacyStats());
+    auto* render_process_host =
+        static_cast<RenderProcessHostImpl*>(i.GetCurrentValue());
+    render_process_host->GetPeerConnectionTrackerHost()->GetLegacyStats();
   }
 }
 

content/common/BUILD.gn

@@ -180,7 +180,6 @@ source_set("common") {
     "mac/font_loader.mm",
     "media/cdm_info.cc",
     "media/media_player_delegate_messages.h",
-    "media/peer_connection_tracker_messages.h",
     "navigation_gesture.h",
     "navigation_params.cc",
     "navigation_params.h",

content/common/content_message_generator.h

@@ -42,12 +42,6 @@
 #ifndef CONTENT_COMMON_MEDIA_MEDIA_PLAYER_DELEGATE_MESSAGES_H_
 #error "Failed to include content/common/media/media_player_delegate_messages.h"
 #endif
-#undef CONTENT_COMMON_MEDIA_PEER_CONNECTION_TRACKER_MESSAGES_H_
-#include "content/common/media/peer_connection_tracker_messages.h"
-#ifndef CONTENT_COMMON_MEDIA_PEER_CONNECTION_TRACKER_MESSAGES_H_
-#error \
-    "Failed to include content/common/media/peer_connection_tracker_messages.h"
-#endif
 #undef CONTENT_COMMON_PAGE_MESSAGES_H_
 #include "content/common/page_messages.h"
 #ifndef CONTENT_COMMON_PAGE_MESSAGES_H_

content/common/media/peer_connection_tracker.mojom

@@ -4,6 +4,8 @@
 
 module content.mojom;
 
+import "mojo/public/mojom/base/values.mojom";
+
 struct PeerConnectionInfo {
   // ID of the peer connection. Unique only within the renderer process.
   int32 lid;
@@ -19,6 +21,25 @@ struct PeerConnectionInfo {
   string url;
 };
 
+// This interface collects data about each peer connection and sends it to the
+// browser process.
+interface PeerConnectionManager {
+    // Called when the browser process reports a suspend event from the OS.
+    OnSuspend();
+
+    // Enable WebRtc event log output.
+    StartEventLog(int32 peer_connection_local_id, int32 output_period_ms);
+
+    // Disable WebRtc event log output.
+    StopEventLog(int32 peer_connection_local_id);
+
+    // Requests standard PeerConnection stats for webrtc-internals.
+    GetStandardStats();
+
+    // Requests legacy PeerConnection stats for webrtc-internals.
+    GetLegacyStats();
+};
+
 // This interface allows forwarding PeerConnection events to WebRTCInternals in
 // the browser process.
 interface PeerConnectionTrackerHost {
@@ -59,4 +80,14 @@ interface PeerConnectionTrackerHost {
 
   // Logs WebRtc log for the connection id.
   WebRtcEventLogWrite(int32 lid, string output);
+
+  // Adds standard PeerConnection stats for webrtc-internals.
+  // |lid| is the renderer local id,
+  // |value| is the list of stats reports.
+  AddStandardStats(int32 lid, mojo_base.mojom.ListValue value);
+
+  // Adds legacy PeerConnection stats for webrtc-internals.
+  // |lid| is the renderer local id,
+  // |value| is the list of stats reports.
+  AddLegacyStats(int32 lid, mojo_base.mojom.ListValue value);
 };

content/common/media/peer_connection_tracker_messages.h

-// 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.
-
-#ifndef CONTENT_COMMON_MEDIA_PEER_CONNECTION_TRACKER_MESSAGES_H_
-#define CONTENT_COMMON_MEDIA_PEER_CONNECTION_TRACKER_MESSAGES_H_
-
-#include "base/values.h"
-#include "content/common/content_export.h"
-#include "ipc/ipc_message_macros.h"
-#include "ipc/ipc_platform_file.h"
-
-#undef IPC_MESSAGE_EXPORT
-#define IPC_MESSAGE_EXPORT CONTENT_EXPORT
-#define IPC_MESSAGE_START PeerConnectionTrackerMsgStart
-
-// Messages sent from PeerConnectionTracker to PeerConnectionTrackerHost.
-IPC_MESSAGE_CONTROL2(PeerConnectionTrackerHost_AddStandardStats,
-                     int /* lid */,
-                     base::ListValue /* value */)
-IPC_MESSAGE_CONTROL2(PeerConnectionTrackerHost_AddLegacyStats,
-                     int /* lid */,
-                     base::ListValue /* value */)
-
-// Messages sent to PeerConnectionTracker.
-IPC_MESSAGE_CONTROL0(PeerConnectionTracker_GetStandardStats)
-IPC_MESSAGE_CONTROL0(PeerConnectionTracker_GetLegacyStats)
-IPC_MESSAGE_CONTROL0(PeerConnectionTracker_OnSuspend)
-IPC_MESSAGE_CONTROL2(PeerConnectionTracker_StartEventLog,
-                     int /* peer_connection_local_id */,
-                     int /* output_period_ms */)
-IPC_MESSAGE_CONTROL1(PeerConnectionTracker_StopEventLog,
-                     int /* peer_connection_local_id */)
-
-#endif  // CONTENT_COMMON_MEDIA_PEER_CONNECTION_TRACKER_MESSAGES_H_

content/public/app/content_renderer_manifest.cc

@@ -32,6 +32,7 @@ const service_manager::Manifest& GetContentRendererManifest() {
                   "content.mojom.ChildProcess",
                   "content.mojom.FrameFactory",
                   "content.mojom.MhtmlFileWriter",
+                  "content.mojom.PeerConnectionManager",
                   "content.mojom.RenderWidgetWindowTreeClientFactory",
                   "content.mojom.ResourceUsageReporter",
                   "IPC.mojom.ChannelBootstrap",

content/renderer/media/webrtc/peer_connection_tracker.h

@@ -7,14 +7,12 @@
 
 #include <map>
 
-#include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "content/common/media/peer_connection_tracker.mojom.h"
-#include "content/public/renderer/render_thread_observer.h"
-#include "ipc/ipc_platform_file.h"
-#include "third_party/blink/public/platform/web_media_stream.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler_client.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_transceiver.h"
 #include "third_party/blink/public/platform/web_rtc_session_description.h"
@@ -36,21 +34,22 @@ class DataChannelInterface;
 
 namespace content {
 class RTCPeerConnectionHandler;
-class RenderThread;
 
 // This class collects data about each peer connection,
 // sends it to the browser process, and handles messages
 // from the browser process.
 class CONTENT_EXPORT PeerConnectionTracker
-    : public RenderThreadObserver,
+    : public mojom::PeerConnectionManager,
       public base::SupportsWeakPtr<PeerConnectionTracker> {
  public:
   static PeerConnectionTracker* GetInstance();
 
+  // TODO(crbug.com/787254): Make these ctors private, and accessible to
+  // tests only.
   explicit PeerConnectionTracker(
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
   PeerConnectionTracker(
-      mojom::PeerConnectionTrackerHostAssociatedPtr host,
+      mojo::Remote<mojom::PeerConnectionTrackerHost> host,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
   ~PeerConnectionTracker() override;
 
@@ -76,15 +75,12 @@ class CONTENT_EXPORT PeerConnectionTracker
     kSetRemoteDescription,
   };
 
-  // RenderThreadObserver implementation.
-  bool OnControlMessageReceived(const IPC::Message& message) override;
+  void Bind(mojo::PendingReceiver<mojom::PeerConnectionManager> receiver);
 
-  //
   // The following methods send an update to the browser process when a
   // PeerConnection update happens. The caller should call the Track* methods
   // after calling RegisterPeerConnection and before calling
   // UnregisterPeerConnection, otherwise the Track* call has no effect.
-  //
 
   // Sends an update when a PeerConnection has been created in Javascript. This
   // should be called once and only once for each PeerConnection. The
@@ -221,10 +217,10 @@ class CONTENT_EXPORT PeerConnectionTracker
   // Sends a new fragment on an RtcEventLog.
   virtual void TrackRtcEventLogWrite(RTCPeerConnectionHandler* pc_handler,
                                      const std::string& output);
-  // For testing: Override the class that gets posted messages.
-  void OverrideSendTargetForTesting(RenderThread* target);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(PeerConnectionTrackerTest, OnSuspend);
+
   // Assign a local ID to a peer connection so that the browser process can
   // uniquely identify a peer connection in the renderer process.
   // The return value will always be positive.
@@ -240,18 +236,13 @@ class CONTENT_EXPORT PeerConnectionTracker
                         const blink::WebRTCRtpTransceiver& transceiver,
                         size_t transceiver_index);
 
-  // IPC Message handler for getting all stats.
-  void OnGetStandardStats();
-  void OnGetLegacyStats();
-
-  // Called when the browser process reports a suspend event from the OS.
-  void OnSuspend();
-
-  // IPC Message handler for starting event log.
-  void OnStartEventLog(int peer_connection_local_id, int output_period_ms);
-
-  // IPC Message handler for stopping event log.
-  void OnStopEventLog(int peer_connection_local_id);
+  // PeerConnectionTracker implementation.
+  void OnSuspend() override;
+  void StartEventLog(int peer_connection_local_id,
+                     int output_period_ms) override;
+  void StopEventLog(int peer_connection_local_id) override;
+  void GetStandardStats() override;
+  void GetLegacyStats() override;
 
   // Called to deliver an update to the host (PeerConnectionTrackerHost).
   // |local_id| - The id of the registered RTCPeerConnectionHandler.
@@ -268,9 +259,8 @@ class CONTENT_EXPORT PeerConnectionTracker
                                 const std::string& callback_type,
                                 const std::string& value);
 
-  RenderThread* SendTarget();
-  const mojom::PeerConnectionTrackerHostAssociatedPtr&
-  GetPeerConnectionTrackerHost();
+  void AddStandardStats(int lid, base::Value value);
+  void AddLegacyStats(int lid, base::Value value);
 
   // This map stores the local ID assigned to each RTCPeerConnectionHandler.
   typedef std::map<RTCPeerConnectionHandler*, int> PeerConnectionLocalIdMap;
@@ -279,9 +269,8 @@ class CONTENT_EXPORT PeerConnectionTracker
   // This keeps track of the next available local ID.
   int next_local_id_;
   THREAD_CHECKER(main_thread_);
-  RenderThread* send_target_for_test_;
-  mojom::PeerConnectionTrackerHostAssociatedPtr
-      peer_connection_tracker_host_ptr_;
+  mojo::Remote<mojom::PeerConnectionTrackerHost> peer_connection_tracker_host_;
+  mojo::Receiver<mojom::PeerConnectionManager> receiver_{this};
 
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
 

content/renderer/media/webrtc/peer_connection_tracker_unittest.cc

@@ -6,11 +6,7 @@
 
 #include "base/test/task_environment.h"
 #include "content/common/media/peer_connection_tracker.mojom.h"
-#include "content/common/media/peer_connection_tracker_messages.h"
-#include "content/public/test/mock_render_thread.h"
 #include "content/renderer/media/webrtc/rtc_peer_connection_handler.h"
-#include "ipc/ipc_message_macros.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
@@ -57,7 +53,7 @@ const char* kDefaultReceiverString =
 
 class MockPeerConnectionTrackerHost : public mojom::PeerConnectionTrackerHost {
  public:
-  MockPeerConnectionTrackerHost() : binding_(this) {}
+  MockPeerConnectionTrackerHost() {}
   MOCK_METHOD3(UpdatePeerConnection,
                void(int, const std::string&, const std::string&));
   MOCK_METHOD1(AddPeerConnection, void(mojom::PeerConnectionInfoPtr));
@@ -70,15 +66,17 @@ class MockPeerConnectionTrackerHost : public mojom::PeerConnectionTrackerHost {
                     const std::string&,
                     const std::string&));
   MOCK_METHOD2(WebRtcEventLogWrite, void(int, const std::string&));
-  mojom::PeerConnectionTrackerHostAssociatedPtr CreateInterfacePtrAndBind() {
-    mojom::PeerConnectionTrackerHostAssociatedPtr
-        peer_connection_tracker_host_ptr_;
-    binding_.Bind(mojo::MakeRequestAssociatedWithDedicatedPipe(
-                      &peer_connection_tracker_host_ptr_),
-                  blink::scheduler::GetSingleThreadTaskRunnerForTesting());
-    return peer_connection_tracker_host_ptr_;
+  MOCK_METHOD2(AddStandardStats, void(int, base::Value));
+  MOCK_METHOD2(AddLegacyStats, void(int, base::Value));
+
+  mojo::Remote<mojom::PeerConnectionTrackerHost> CreatePendingRemoteAndBind() {
+    receiver_.reset();
+    return mojo::Remote<mojom::PeerConnectionTrackerHost>(
+        receiver_.BindNewPipeAndPassRemote(
+            blink::scheduler::GetSingleThreadTaskRunnerForTesting()));
   }
-  mojo::AssociatedBinding<mojom::PeerConnectionTrackerHost> binding_;
+
+  mojo::Receiver<mojom::PeerConnectionTrackerHost> receiver_{this};
 };
 
 // Creates a transceiver that is expected to be logged as
@@ -140,7 +138,7 @@ class PeerConnectionTrackerTest : public ::testing::Test {
   void CreateTrackerWithMocks() {
     mock_host_.reset(new MockPeerConnectionTrackerHost());
     tracker_.reset(new PeerConnectionTracker(
-        mock_host_->CreateInterfacePtrAndBind(),
+        mock_host_->CreatePendingRemoteAndBind(),
         blink::scheduler::GetSingleThreadTaskRunnerForTesting()));
   }
 
@@ -187,8 +185,7 @@ TEST_F(PeerConnectionTrackerTest, OnSuspend) {
   CreateTrackerWithMocks();
   CreateAndRegisterPeerConnectionHandler();
   EXPECT_CALL(*mock_handler_, CloseClientPeerConnection());
-  std::unique_ptr<IPC::Message> message(new PeerConnectionTracker_OnSuspend());
-  tracker_->OnControlMessageReceived(*message.get());
+  tracker_->OnSuspend();
 }
 
 TEST_F(PeerConnectionTrackerTest, AddTransceiverWithOptionalValuesPresent) {

content/renderer/render_thread_impl.cc

@@ -753,8 +753,6 @@ void RenderThreadImpl::Init() {
   browser_plugin_manager_.reset(new BrowserPluginManager());
   AddObserver(browser_plugin_manager_.get());
 
-  AddObserver(PeerConnectionTracker::GetInstance());
-
   unfreezable_message_filter_ = new UnfreezableMessageFilter(this);
   AddFilter(unfreezable_message_filter_.get());
 
@@ -767,6 +765,13 @@ void RenderThreadImpl::Init() {
   registry->AddInterface(base::BindRepeating(CreateResourceUsageReporter,
                                              weak_factory_.GetWeakPtr()),
                          base::ThreadTaskRunnerHandle::Get());
+  registry->AddInterface(
+      // Unretained here is safe, since PeerConnectionTracker instance
+      // is a leaky singleton.
+      base::BindRepeating(
+          &PeerConnectionTracker::Bind,
+          base::Unretained(PeerConnectionTracker::GetInstance())),
+      base::ThreadTaskRunnerHandle::Get());
 
   if (base::FeatureList::IsEnabled(
           blink::features::kOffMainThreadServiceWorkerStartup)) {