Remove workaround now that WebRTC supports component build.

Bug: webrtc:9419
Change-Id: I568367055910d651375ddc0c1903f674a6876fd8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1919345Reviewed-by: Steve Anton <steveanton@chromium.org>
Commit-Queue: Mirko Bonadei <mbonadei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715814}

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

@@ -122,9 +122,6 @@ class BLINK_MODULES_EXPORT PeerConnectionDependencyFactory
   // An rtc::Thread will have already been created.
   scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcWorkerTaskRunner();
 
-  // Returns the rtc::Thread instance associated with the WebRTC worker thread.
-  // TODO(bugs.webrtc.org/9419): Remove once WebRTC can be built as a component.
-  rtc::Thread* GetWebRtcWorkerThreadRtcThread();
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetWebRtcSignalingTaskRunner();
 

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_adapter_impl.cc

@@ -14,16 +14,10 @@ namespace blink {
 IceTransportAdapterImpl::IceTransportAdapterImpl(
     Delegate* delegate,
     std::unique_ptr<cricket::PortAllocator> port_allocator,
-    std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory,
-    rtc::Thread* thread)
+    std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory)
     : delegate_(delegate),
       port_allocator_(std::move(port_allocator)),
       async_resolver_factory_(std::move(async_resolver_factory)) {
-  // TODO(bugs.webrtc.org/9419): Remove once WebRTC can be built as a component.
-  if (!rtc::ThreadManager::Instance()->CurrentThread()) {
-    rtc::ThreadManager::Instance()->SetCurrentThread(thread);
-  }
-
   // These settings are copied from PeerConnection:
   // https://codesearch.chromium.org/chromium/src/third_party/webrtc/pc/peerconnection.cc?l=4708&rcl=820ebd0f661696043959b5105b2814e0edd8b694
   port_allocator_->set_step_delay(cricket::kMinimumStepDelay);
@@ -55,14 +49,8 @@ IceTransportAdapterImpl::IceTransportAdapterImpl(
 
 IceTransportAdapterImpl::IceTransportAdapterImpl(
     Delegate* delegate,
-    rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport,
-    rtc::Thread* thread)
+    rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport)
     : delegate_(delegate), ice_transport_channel_(ice_transport) {
-  // TODO(bugs.webrtc.org/9419): Remove once WebRTC can be built as a component.
-  if (!rtc::ThreadManager::Instance()->CurrentThread()) {
-    rtc::ThreadManager::Instance()->SetCurrentThread(thread);
-  }
-
   // The native webrtc peer connection might have been closed in the meantime,
   // clearing the ice transport channel; don't do anything in that case. |this|
   // will eventually be destroyed when the blink layer gets notified by the

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_adapter_impl.h

@@ -20,21 +20,17 @@ class IceTransportAdapterImpl final : public IceTransportAdapter,
  public:
   // Must be constructed on the WebRTC worker thread.
   // |delegate| must outlive the IceTransportAdapter.
-  // |thread| should be the rtc::Thread instance associated with the WebRTC
-  // worker thread.
   IceTransportAdapterImpl(
       Delegate* delegate,
       std::unique_ptr<cricket::PortAllocator> port_allocator,
-      std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory,
-      rtc::Thread* thread);
+      std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory);
 
   // Create an IceTransportAdapter for an existing |ice_transport_channel|
   // object. In this case, |port_allocator_|, |async_resolver_factory_| and
   // |quic_packet_transport_adapter_| are not used (and null).
   IceTransportAdapterImpl(
       Delegate* delegate,
-      rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport_channel,
-      rtc::Thread* thread);
+      rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport_channel);
 
   ~IceTransportAdapterImpl() override;
 

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

@@ -608,12 +608,6 @@ PeerConnectionDependencyFactory::GetWebRtcWorkerTaskRunner() {
                                            : nullptr;
 }
 
-rtc::Thread* PeerConnectionDependencyFactory::GetWebRtcWorkerThreadRtcThread() {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  EnsureInitialized();
-  return chrome_worker_thread_.IsRunning() ? worker_thread_ : nullptr;
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 PeerConnectionDependencyFactory::GetWebRtcSignalingTaskRunner() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

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

@@ -64,22 +64,17 @@ class DtlsIceTransportAdapterCrossThreadFactory
       rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport)
       : ice_transport_(ice_transport) {}
   void InitializeOnMainThread(LocalFrame& frame) override {
-    DCHECK(!worker_thread_rtc_thread_);
-    worker_thread_rtc_thread_ = PeerConnectionDependencyFactory::GetInstance()
-                                    ->GetWebRtcWorkerThreadRtcThread();
   }
 
   std::unique_ptr<IceTransportAdapter> ConstructOnWorkerThread(
       IceTransportAdapter::Delegate* delegate) override {
     DCHECK(ice_transport_);
-    DCHECK(worker_thread_rtc_thread_);
-    return std::make_unique<IceTransportAdapterImpl>(
-        delegate, std::move(ice_transport_), worker_thread_rtc_thread_);
+    return std::make_unique<IceTransportAdapterImpl>(delegate,
+                                                     std::move(ice_transport_));
   }
 
  private:
   rtc::scoped_refptr<webrtc::IceTransportInterface> ice_transport_;
-  rtc::Thread* worker_thread_rtc_thread_ = nullptr;
 };
 
 class DefaultIceTransportAdapterCrossThreadFactory
@@ -87,7 +82,6 @@ class DefaultIceTransportAdapterCrossThreadFactory
  public:
   void InitializeOnMainThread(LocalFrame& frame) override {
     DCHECK(!port_allocator_);
-    DCHECK(!worker_thread_rtc_thread_);
     DCHECK(!async_resolver_factory_);
 
     auto* rtc_dependency_factory =
@@ -96,24 +90,20 @@ class DefaultIceTransportAdapterCrossThreadFactory
         frame.Client()->GetWebFrame());
     async_resolver_factory_ =
         rtc_dependency_factory->CreateAsyncResolverFactory();
-    worker_thread_rtc_thread_ =
-        rtc_dependency_factory->GetWebRtcWorkerThreadRtcThread();
   }
 
   std::unique_ptr<IceTransportAdapter> ConstructOnWorkerThread(
       IceTransportAdapter::Delegate* delegate) override {
     DCHECK(port_allocator_);
-    DCHECK(worker_thread_rtc_thread_);
     DCHECK(async_resolver_factory_);
     return std::make_unique<IceTransportAdapterImpl>(
         delegate, std::move(port_allocator_),
-        std::move(async_resolver_factory_), worker_thread_rtc_thread_);
+        std::move(async_resolver_factory_));
   }
 
  private:
   std::unique_ptr<cricket::PortAllocator> port_allocator_;
   std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory_;
-  rtc::Thread* worker_thread_rtc_thread_ = nullptr;
 };
 
 }  // namespace