Refactoring: Replace ThreadTaskRunnerHandle::Get() usages

This CL is pure refactoring. We aim to reduce

ThreadTaskRunnerHandle: :Get() usages as much as possible.
Change-Id: I13cb655c77f5b6c78d977e680fa92aa4278f38f5
Reviewed-on: https://chromium-review.googlesource.com/1249477Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Max Morin <maxmorin@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#595039}

content/renderer/media/webrtc/peer_connection_tracker.cc

@@ -433,8 +433,9 @@ static std::unique_ptr<base::DictionaryValue> GetDictValue(
 
 class InternalStatsObserver : public webrtc::StatsObserver {
  public:
-  explicit InternalStatsObserver(int lid)
-      : lid_(lid), main_thread_(base::ThreadTaskRunnerHandle::Get()) {}
+  InternalStatsObserver(int lid,
+                        scoped_refptr<base::SingleThreadTaskRunner> main_thread)
+      : lid_(lid), main_thread_(std::move(main_thread)) {}
 
   void OnComplete(const StatsReports& reports) override {
     std::unique_ptr<base::ListValue> list(new base::ListValue());
@@ -473,14 +474,19 @@ class InternalStatsObserver : public webrtc::StatsObserver {
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
 };
 
-PeerConnectionTracker::PeerConnectionTracker()
-    : next_local_id_(1), send_target_for_test_(nullptr) {}
+PeerConnectionTracker::PeerConnectionTracker(
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
+    : next_local_id_(1),
+      send_target_for_test_(nullptr),
+      main_thread_task_runner_(std::move(main_thread_task_runner)) {}
 
 PeerConnectionTracker::PeerConnectionTracker(
-    mojom::PeerConnectionTrackerHostAssociatedPtr host)
+    mojom::PeerConnectionTrackerHostAssociatedPtr host,
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : next_local_id_(1),
       send_target_for_test_(nullptr),
-      peer_connection_tracker_host_ptr_(std::move(host)) {}
+      peer_connection_tracker_host_ptr_(std::move(host)),
+      main_thread_task_runner_(std::move(main_thread_task_runner)) {}
 
 PeerConnectionTracker::~PeerConnectionTracker() {
 }
@@ -508,7 +514,8 @@ void PeerConnectionTracker::OnGetAllStats() {
   for (PeerConnectionIdMap::iterator it = peer_connection_id_map_.begin();
        it != peer_connection_id_map_.end(); ++it) {
     rtc::scoped_refptr<InternalStatsObserver> observer(
-        new rtc::RefCountedObject<InternalStatsObserver>(it->second));
+        new rtc::RefCountedObject<InternalStatsObserver>(
+            it->second, main_thread_task_runner_));
 
     it->first->GetStats(observer,
                         webrtc::PeerConnectionInterface::kStatsOutputLevelDebug,

content/renderer/media/webrtc/peer_connection_tracker.h

@@ -45,8 +45,11 @@ class CONTENT_EXPORT PeerConnectionTracker
     : public RenderThreadObserver,
       public base::SupportsWeakPtr<PeerConnectionTracker> {
  public:
-  PeerConnectionTracker();
-  PeerConnectionTracker(mojom::PeerConnectionTrackerHostAssociatedPtr host);
+  explicit PeerConnectionTracker(
+      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
+  PeerConnectionTracker(
+      mojom::PeerConnectionTrackerHostAssociatedPtr host,
+      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
   ~PeerConnectionTracker() override;
 
   enum Source {
@@ -262,6 +265,8 @@ class CONTENT_EXPORT PeerConnectionTracker
   mojom::PeerConnectionTrackerHostAssociatedPtr
       peer_connection_tracker_host_ptr_;
 
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(PeerConnectionTracker);
 };
 

content/renderer/media/webrtc/peer_connection_tracker_unittest.cc

@@ -151,8 +151,9 @@ class PeerConnectionTrackerTest : public ::testing::Test {
  public:
   void CreateTrackerWithMocks() {
     mock_host_.reset(new MockPeerConnectionTrackerHost());
-    tracker_.reset(
-        new PeerConnectionTracker(mock_host_->CreateInterfacePtrAndBind()));
+    tracker_.reset(new PeerConnectionTracker(
+        mock_host_->CreateInterfacePtrAndBind(),
+        blink::scheduler::GetSingleThreadTaskRunnerForTesting()));
     target_thread_.reset(new MockSendTargetThread());
     tracker_->OverrideSendTargetForTesting(target_thread_.get());
   }
@@ -177,7 +178,8 @@ class PeerConnectionTrackerTest : public ::testing::Test {
 }  // namespace
 
 TEST_F(PeerConnectionTrackerTest, CreatingObject) {
-  PeerConnectionTracker tracker;
+  PeerConnectionTracker tracker(
+      blink::scheduler::GetSingleThreadTaskRunnerForTesting());
 }
 
 TEST_F(PeerConnectionTrackerTest, TrackCreateOffer) {

content/renderer/media/webrtc/rtc_dtmf_sender_handler.cc

@@ -22,8 +22,9 @@ class RtcDtmfSenderHandler::Observer :
     public base::RefCountedThreadSafe<Observer>,
     public webrtc::DtmfSenderObserverInterface {
  public:
-  explicit Observer(const base::WeakPtr<RtcDtmfSenderHandler>& handler)
-      : main_thread_(base::ThreadTaskRunnerHandle::Get()), handler_(handler) {}
+  explicit Observer(scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+                    const base::WeakPtr<RtcDtmfSenderHandler>& handler)
+      : main_thread_(std::move(main_thread)), handler_(handler) {}
 
  private:
   friend class base::RefCountedThreadSafe<Observer>;
@@ -51,10 +52,12 @@ class RtcDtmfSenderHandler::Observer :
   base::WeakPtr<RtcDtmfSenderHandler> handler_;
 };
 
-RtcDtmfSenderHandler::RtcDtmfSenderHandler(DtmfSenderInterface* dtmf_sender)
+RtcDtmfSenderHandler::RtcDtmfSenderHandler(
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+    DtmfSenderInterface* dtmf_sender)
     : dtmf_sender_(dtmf_sender), webkit_client_(nullptr), weak_factory_(this) {
   DVLOG(1) << "::ctor";
-  observer_ = new Observer(weak_factory_.GetWeakPtr());
+  observer_ = new Observer(std::move(main_thread), weak_factory_.GetWeakPtr());
   dtmf_sender_->RegisterObserver(observer_.get());
 }
 

content/renderer/media/webrtc/rtc_dtmf_sender_handler.h

@@ -16,6 +16,10 @@
 #include "third_party/blink/public/platform/web_rtc_dtmf_sender_handler_client.h"
 #include "third_party/webrtc/api/dtmfsenderinterface.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace content {
 
 // RtcDtmfSenderHandler is a delegate for the RTC DTMF Sender API messages
@@ -27,7 +31,8 @@ namespace content {
 class CONTENT_EXPORT RtcDtmfSenderHandler
     : public blink::WebRTCDTMFSenderHandler {
  public:
-  explicit RtcDtmfSenderHandler(webrtc::DtmfSenderInterface* dtmf_sender);
+  RtcDtmfSenderHandler(scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+                       webrtc::DtmfSenderInterface* dtmf_sender);
   ~RtcDtmfSenderHandler() override;
 
   // blink::WebRTCDTMFSenderHandler implementation.

content/renderer/media/webrtc/rtc_peer_connection_handler_unittest.cc

@@ -148,6 +148,10 @@ class MockRTCStatsRequest : public LocalRTCStatsRequest {
 
 class MockPeerConnectionTracker : public PeerConnectionTracker {
  public:
+  MockPeerConnectionTracker()
+      : PeerConnectionTracker(
+            blink::scheduler::GetSingleThreadTaskRunnerForTesting()) {}
+
   MOCK_METHOD1(UnregisterPeerConnection,
                void(RTCPeerConnectionHandler* pc_handler));
   // TODO(jiayl): add coverage for the following methods

content/renderer/media/webrtc/rtc_rtp_sender.cc

@@ -185,7 +185,8 @@ class RTCRtpSender::RTCRtpSenderInternal
     // webrtc signalling thread.
     DCHECK(main_task_runner_->BelongsToCurrentThread());
     auto dtmf_sender = webrtc_sender_->GetDtmfSender();
-    return std::make_unique<RtcDtmfSenderHandler>(dtmf_sender);
+    return std::make_unique<RtcDtmfSenderHandler>(main_task_runner_,
+                                                  dtmf_sender);
   }
 
   std::unique_ptr<webrtc::RtpParameters> GetParameters() {

content/renderer/media/webrtc/webrtc_audio_sink.cc

@@ -18,9 +18,13 @@ namespace content {
 WebRtcAudioSink::WebRtcAudioSink(
     const std::string& label,
     scoped_refptr<webrtc::AudioSourceInterface> track_source,
-    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner)
-    : adapter_(new rtc::RefCountedObject<Adapter>(
-          label, std::move(track_source), std::move(signaling_task_runner))),
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+    : adapter_(
+          new rtc::RefCountedObject<Adapter>(label,
+                                             std::move(track_source),
+                                             std::move(signaling_task_runner),
+                                             std::move(main_task_runner))),
       fifo_(base::Bind(&WebRtcAudioSink::DeliverRebufferedAudio,
                        base::Unretained(this))) {
   DVLOG(1) << "WebRtcAudioSink::WebRtcAudioSink()";
@@ -100,12 +104,14 @@ void DereferenceOnMainThread(
 WebRtcAudioSink::Adapter::Adapter(
     const std::string& label,
     scoped_refptr<webrtc::AudioSourceInterface> source,
-    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label),
       source_(std::move(source)),
       signaling_task_runner_(std::move(signaling_task_runner)),
-      main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+      main_task_runner_(std::move(main_task_runner)) {
   DCHECK(signaling_task_runner_);
+  DCHECK(main_task_runner_);
 }
 
 WebRtcAudioSink::Adapter::~Adapter() {

content/renderer/media/webrtc/webrtc_audio_sink.h

@@ -40,7 +40,8 @@ class CONTENT_EXPORT WebRtcAudioSink : public MediaStreamAudioSink {
   WebRtcAudioSink(
       const std::string& label,
       scoped_refptr<webrtc::AudioSourceInterface> track_source,
-      scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
 
   ~WebRtcAudioSink() override;
 
@@ -72,7 +73,8 @@ class CONTENT_EXPORT WebRtcAudioSink : public MediaStreamAudioSink {
    public:
     Adapter(const std::string& label,
             scoped_refptr<webrtc::AudioSourceInterface> source,
-            scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner);
+            scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner,
+            scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
 
     base::SingleThreadTaskRunner* signaling_task_runner() const {
       return signaling_task_runner_.get();

content/renderer/media/webrtc/webrtc_media_stream_track_adapter.cc

@@ -149,7 +149,7 @@ void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack(
   webrtc::AudioSourceInterface* source_interface = nullptr;
   local_track_audio_sink_.reset(
       new WebRtcAudioSink(web_track_.Id().Utf8(), source_interface,
-                          factory_->GetWebRtcSignalingThread()));
+                          factory_->GetWebRtcSignalingThread(), main_thread_));
 
   if (auto* media_stream_source = ProcessedLocalAudioSource::From(
           MediaStreamAudioSource::From(web_track_.Source()))) {

content/renderer/render_thread_impl.cc

@@ -775,7 +775,8 @@ void RenderThreadImpl::Init() {
   browser_plugin_manager_.reset(new BrowserPluginManager());
   AddObserver(browser_plugin_manager_.get());
 
-  peer_connection_tracker_.reset(new PeerConnectionTracker());
+  peer_connection_tracker_.reset(
+      new PeerConnectionTracker(main_thread_runner()));
   AddObserver(peer_connection_tracker_.get());
 
   p2p_socket_dispatcher_ = new P2PSocketDispatcher();