Replace uses blink::Platform::CreateWebRtcAsyncResolverFactory

... by its PeerConnectionDependencyFactory counterpart.

This is now possible after [1], where
peer_connection_dependency_factory.cc|h is moved to Blink.

The CL also removes blink::Platform::CreateWebRtcPortAllocator()
and its overrides altogether. They are not called anymore.

[1] https://crrev.com/c/1805159

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

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

content/renderer/renderer_blink_platform_impl.cc

@@ -562,23 +562,6 @@ RendererBlinkPlatformImpl::GetWebRtcWorkerThread() {
   return rtc_dependency_factory->GetWebRtcWorkerThread();
 }
 
-std::unique_ptr<cricket::PortAllocator>
-RendererBlinkPlatformImpl::CreateWebRtcPortAllocator(
-    blink::WebLocalFrame* frame) {
-  auto* rtc_dependency_factory =
-      blink::PeerConnectionDependencyFactory::GetInstance();
-  rtc_dependency_factory->EnsureInitialized();
-  return rtc_dependency_factory->CreatePortAllocator(frame);
-}
-
-std::unique_ptr<webrtc::AsyncResolverFactory>
-RendererBlinkPlatformImpl::CreateWebRtcAsyncResolverFactory() {
-  auto* rtc_dependency_factory =
-      blink::PeerConnectionDependencyFactory::GetInstance();
-  rtc_dependency_factory->EnsureInitialized();
-  return rtc_dependency_factory->CreateAsyncResolverFactory();
-}
-
 //------------------------------------------------------------------------------
 
 base::Optional<double>

content/renderer/renderer_blink_platform_impl.h

@@ -131,10 +131,6 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       blink::WebRTCPeerConnectionHandlerClient* client,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcWorkerThread() override;
-  std::unique_ptr<cricket::PortAllocator> CreateWebRtcPortAllocator(
-      blink::WebLocalFrame* frame) override;
-  std::unique_ptr<webrtc::AsyncResolverFactory>
-  CreateWebRtcAsyncResolverFactory() override;
   base::Optional<double> GetWebRtcMaxCaptureFrameRate() override;
   scoped_refptr<media::AudioRendererSink> NewAudioRendererSink(
       blink::WebAudioDeviceSourceType source_type,

third_party/blink/public/platform/platform.h

@@ -72,10 +72,6 @@ namespace base {
 class SingleThreadTaskRunner;
 }
 
-namespace cricket {
-class PortAllocator;
-}
-
 namespace gpu {
 class GpuMemoryBufferManager;
 }
@@ -101,10 +97,6 @@ namespace viz {
 class ContextProvider;
 }
 
-namespace webrtc {
-class AsyncResolverFactory;
-}
-
 namespace blink {
 
 class ThreadSafeBrowserInterfaceBrokerProxy;
@@ -576,14 +568,6 @@ class BLINK_PLATFORM_EXPORT Platform {
     return nullptr;
   }
 
-  // May return null if WebRTC functionality is not implemented.
-  virtual std::unique_ptr<cricket::PortAllocator> CreateWebRtcPortAllocator(
-      WebLocalFrame* frame);
-
-  // May return null if WebRTC functionality is not implemented.
-  virtual std::unique_ptr<webrtc::AsyncResolverFactory>
-  CreateWebRtcAsyncResolverFactory();
-
   // Checks if the default minimum starting volume value for the AGC is
   // overridden on the command line.
   virtual base::Optional<double> GetWebRtcMaxCaptureFrameRate() {

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

@@ -364,6 +364,7 @@ std::unique_ptr<cricket::PortAllocator>
 PeerConnectionDependencyFactory::CreatePortAllocator(
     blink::WebLocalFrame* web_frame) {
   DCHECK(web_frame);
+  EnsureInitialized();
 
   // Copy the flag from Preference associated with this WebLocalFrame.
   P2PPortAllocator::Config port_config;
@@ -464,6 +465,7 @@ PeerConnectionDependencyFactory::CreatePortAllocator(
 
 std::unique_ptr<webrtc::AsyncResolverFactory>
 PeerConnectionDependencyFactory::CreateAsyncResolverFactory() {
+  EnsureInitialized();
   return std::make_unique<ProxyAsyncResolverFactory>(socket_factory_.get());
 }
 

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

@@ -92,14 +92,12 @@ class DefaultIceTransportAdapterCrossThreadFactory
 
     auto* rtc_dependency_factory =
         blink::PeerConnectionDependencyFactory::GetInstance();
-    rtc_dependency_factory->EnsureInitialized();
     port_allocator_ = rtc_dependency_factory->CreatePortAllocator(
         frame.Client()->GetWebFrame());
-
     async_resolver_factory_ =
-        Platform::Current()->CreateWebRtcAsyncResolverFactory();
-    worker_thread_rtc_thread_ = PeerConnectionDependencyFactory::GetInstance()
-                                    ->GetWebRtcWorkerThreadRtcThread();
+        rtc_dependency_factory->CreateAsyncResolverFactory();
+    worker_thread_rtc_thread_ =
+        rtc_dependency_factory->GetWebRtcWorkerThreadRtcThread();
   }
 
   std::unique_ptr<IceTransportAdapter> ConstructOnWorkerThread(

third_party/blink/renderer/platform/exported/platform.cc

@@ -63,7 +63,6 @@
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
 #include "third_party/blink/renderer/platform/wtf/hash_map.h"
-#include "third_party/webrtc/api/async_resolver_factory.h"
 #include "third_party/webrtc/api/rtp_parameters.h"
 #include "third_party/webrtc/p2p/base/port_allocator.h"
 
@@ -342,14 +341,4 @@ Platform::CreateRTCPeerConnectionHandler(
   return nullptr;
 }
 
-std::unique_ptr<cricket::PortAllocator> Platform::CreateWebRtcPortAllocator(
-    WebLocalFrame* frame) {
-  return nullptr;
-}
-
-std::unique_ptr<webrtc::AsyncResolverFactory>
-Platform::CreateWebRtcAsyncResolverFactory() {
-  return nullptr;
-}
-
 }  // namespace blink