Change blink::PeerConnectionDependencyFactory ownership

... off of content::RenderThreadImpl.

This CL changes the ownership of blink::PeerConnectionDependencyFactory
as per section 5.1.1 in the design document [1].

[1] https://docs.google.com/document/d/1AJKVA5U4nDkyDB9p4ROrggWXadCxyy-grKaE9KS5vOU/

Quoting the document:

  "
  PeerConnectionDependencyFactory is currently owned by RenderThreadImpl in content,
  which makes it a single object per renderer process. This ownership must be moved to
  a suitable place in Blink. A possibility is to keep it as a global object (using
  DEFINE_STATIC_LOCAL).
  The disadvantage of this approach is that PCDF would never be destroyed, whereas
  it is currently destroyed by the RenderThreadImpl destructor, but this is acceptable.
  "

This move will allow a set of blink::Platform methods to be removed
(follow up CL).

BUG=787254
R=guidou@chromium.org, haraken@chromium.org

Change-Id: Ie79f13cfd90c56fcbed50142802b0fcda480c43e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1807657
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#697750}

content/renderer/media/webrtc/rtc_certificate_generator.cc

@@ -12,7 +12,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/renderer/render_thread_impl.h"
 #include "media/media_buildflags.h"
 #include "third_party/blink/public/web/modules/peerconnection/peer_connection_dependency_factory.h"
 #include "third_party/webrtc/api/scoped_refptr.h"
@@ -108,8 +107,8 @@ void GenerateCertificateWithOptionalExpiration(
     blink::WebRTCCertificateCallback completion_callback,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK(WebRTCKeyParamsToKeyParams(key_params).IsValid());
-  blink::PeerConnectionDependencyFactory* pc_dependency_factory =
-      RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
+  auto* pc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   pc_dependency_factory->EnsureInitialized();
 
   scoped_refptr<RTCCertificateGeneratorRequest> request =

content/renderer/render_thread_impl.cc

@@ -92,7 +92,6 @@
 #include "content/renderer/media/gpu/gpu_video_accelerator_factories_impl.h"
 #include "content/renderer/media/render_media_client.h"
 #include "content/renderer/media/webrtc/peer_connection_tracker.h"
-#include "content/renderer/media/webrtc/rtc_peer_connection_handler.h"
 #include "content/renderer/net_info_helper.h"
 #include "content/renderer/render_frame_proxy.h"
 #include "content/renderer/render_process_impl.h"
@@ -147,7 +146,6 @@
 #include "third_party/blink/public/platform/web_scoped_page_pauser.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/web/blink.h"
-#include "third_party/blink/public/web/modules/peerconnection/peer_connection_dependency_factory.h"
 #include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/web_frame.h"
 #include "third_party/blink/public/web/web_script_controller.h"
@@ -746,9 +744,6 @@ void RenderThreadImpl::Init() {
       new PeerConnectionTracker(main_thread_runner()));
   AddObserver(peer_connection_tracker_.get());
 
-  peer_connection_factory_.reset(new blink::PeerConnectionDependencyFactory(
-      /*create_p2p_socket_dispatcher =*/true));
-
   unfreezable_message_filter_ = new UnfreezableMessageFilter(this);
   AddFilter(unfreezable_message_filter_.get());
 
@@ -1999,11 +1994,6 @@ RenderThreadImpl::GetAssociatedInterfaceRegistry() {
   return &associated_interfaces_;
 }
 
-blink::PeerConnectionDependencyFactory*
-RenderThreadImpl::GetPeerConnectionDependencyFactory() {
-  return peer_connection_factory_.get();
-}
-
 mojom::RenderMessageFilter* RenderThreadImpl::render_message_filter() {
   if (!render_message_filter_)
     GetChannel()->GetRemoteAssociatedInterface(&render_message_filter_);

content/renderer/render_thread_impl.h

@@ -72,7 +72,6 @@
 class SkBitmap;
 
 namespace blink {
-class PeerConnectionDependencyFactory;
 class WebVideoCaptureImplManager;
 }
 
@@ -308,9 +307,6 @@ class CONTENT_EXPORT RenderThreadImpl
     return browser_plugin_manager_.get();
   }
 
-  // Returns a factory used for creating RTC PeerConnection objects.
-  blink::PeerConnectionDependencyFactory* GetPeerConnectionDependencyFactory();
-
   PeerConnectionTracker* peer_connection_tracker() {
     return peer_connection_tracker_.get();
   }
@@ -577,9 +573,6 @@ class CONTENT_EXPORT RenderThreadImpl
 
   std::unique_ptr<BrowserPluginManager> browser_plugin_manager_;
 
-  std::unique_ptr<blink::PeerConnectionDependencyFactory>
-      peer_connection_factory_;
-
   // This is used to communicate to the browser process the status
   // of all the peer connections created in the renderer.
   std::unique_ptr<PeerConnectionTracker> peer_connection_tracker_;

content/renderer/render_view_impl.cc

@@ -124,7 +124,6 @@
 #include "third_party/blink/public/platform/web_vector.h"
 #include "third_party/blink/public/public_buildflags.h"
 #include "third_party/blink/public/web/modules/mediastream/web_media_stream_device_observer.h"
-#include "third_party/blink/public/web/modules/peerconnection/peer_connection_dependency_factory.h"
 #include "third_party/blink/public/web/web_autofill_client.h"
 #include "third_party/blink/public/web/web_ax_object.h"
 #include "third_party/blink/public/web/web_document.h"

content/renderer/renderer_blink_platform_impl.cc

@@ -542,18 +542,13 @@ RendererBlinkPlatformImpl::CreateRTCPeerConnectionHandler(
   // PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler
   // when it the file gets Onion soup'ed.
 
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  if (!render_thread)
-    return nullptr;
-
   // Save histogram data so we can see how much PeerConnection is used.
   // The histogram counts the number of calls to the JS API
   // RTCPeerConnection.
   UpdateWebRTCMethodCount(blink::WebRTCAPIName::kRTCPeerConnection);
 
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   return std::make_unique<RTCPeerConnectionHandler>(
       client, rtc_dependency_factory, task_runner);
 }
@@ -569,29 +564,23 @@ RendererBlinkPlatformImpl::CreateRTCCertificateGenerator() {
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererBlinkPlatformImpl::GetWebRtcWorkerThread() {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   rtc_dependency_factory->EnsureInitialized();
   return rtc_dependency_factory->GetWebRtcWorkerThread();
 }
 
 rtc::Thread* RendererBlinkPlatformImpl::GetWebRtcWorkerThreadRtcThread() {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   rtc_dependency_factory->EnsureInitialized();
   return rtc_dependency_factory->GetWebRtcWorkerThreadRtcThread();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererBlinkPlatformImpl::GetWebRtcSignalingTaskRunner() {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   rtc_dependency_factory->EnsureInitialized();
   return rtc_dependency_factory->GetWebRtcSignalingThread();
 }
@@ -599,20 +588,16 @@ RendererBlinkPlatformImpl::GetWebRtcSignalingTaskRunner() {
 std::unique_ptr<cricket::PortAllocator>
 RendererBlinkPlatformImpl::CreateWebRtcPortAllocator(
     blink::WebLocalFrame* frame) {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   rtc_dependency_factory->EnsureInitialized();
   return rtc_dependency_factory->CreatePortAllocator(frame);
 }
 
 std::unique_ptr<webrtc::AsyncResolverFactory>
 RendererBlinkPlatformImpl::CreateWebRtcAsyncResolverFactory() {
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  DCHECK(render_thread);
-  blink::PeerConnectionDependencyFactory* rtc_dependency_factory =
-      render_thread->GetPeerConnectionDependencyFactory();
+  auto* rtc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   rtc_dependency_factory->EnsureInitialized();
   return rtc_dependency_factory->CreateAsyncResolverFactory();
 }
@@ -622,8 +607,8 @@ RendererBlinkPlatformImpl::CreateWebRtcAsyncResolverFactory() {
 std::unique_ptr<webrtc::RtpCapabilities>
 RendererBlinkPlatformImpl::GetRtpSenderCapabilities(
     const blink::WebString& kind) {
-  blink::PeerConnectionDependencyFactory* pc_dependency_factory =
-      RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
+  auto* pc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   pc_dependency_factory->EnsureInitialized();
   return pc_dependency_factory->GetSenderCapabilities(kind.Utf8());
 }
@@ -631,8 +616,8 @@ RendererBlinkPlatformImpl::GetRtpSenderCapabilities(
 std::unique_ptr<webrtc::RtpCapabilities>
 RendererBlinkPlatformImpl::GetRtpReceiverCapabilities(
     const blink::WebString& kind) {
-  blink::PeerConnectionDependencyFactory* pc_dependency_factory =
-      RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
+  auto* pc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   pc_dependency_factory->EnsureInitialized();
   return pc_dependency_factory->GetReceiverCapabilities(kind.Utf8());
 }
@@ -669,8 +654,8 @@ RendererBlinkPlatformImpl::GetAudioSourceLatencyType(
 
 blink::WebRtcAudioDeviceImpl*
 RendererBlinkPlatformImpl::GetWebRtcAudioDevice() {
-  blink::PeerConnectionDependencyFactory* pc_dependency_factory =
-      RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
+  auto* pc_dependency_factory =
+      blink::PeerConnectionDependencyFactory::GetInstance();
   return pc_dependency_factory->GetWebRtcAudioDevice();
 }
 

third_party/blink/public/web/modules/peerconnection/peer_connection_dependency_factory.h

@@ -48,9 +48,14 @@ class WebRtcAudioDeviceImpl;
 class BLINK_MODULES_EXPORT PeerConnectionDependencyFactory
     : base::MessageLoopCurrent::DestructionObserver {
  public:
+  // TODO(crbug.com/787254): Make this constructor private, when
+  // MockPeerConnectionDependencyFactory gets moved to blink.
+  // (friend class declaration will be needed).
   PeerConnectionDependencyFactory(bool create_p2p_socket_dispatcher);
   ~PeerConnectionDependencyFactory() override;
 
+  static PeerConnectionDependencyFactory* GetInstance();
+
   // Create a RTCPeerConnectionHandler object that implements the
   // WebKit WebRTCPeerConnectionHandler interface.
   std::unique_ptr<blink::WebRTCPeerConnectionHandler>

third_party/blink/renderer/modules/peerconnection/peer_connection_dependency_factory.cc

@@ -126,6 +126,13 @@ PeerConnectionDependencyFactory::~PeerConnectionDependencyFactory() {
   DCHECK(!pc_factory_);
 }
 
+PeerConnectionDependencyFactory*
+PeerConnectionDependencyFactory::GetInstance() {
+  DEFINE_STATIC_LOCAL(PeerConnectionDependencyFactory, instance,
+                      (/*create_p2p_socket_dispatcher= */ true));
+  return &instance;
+}
+
 std::unique_ptr<blink::WebRTCPeerConnectionHandler>
 PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client,