Fix WebRTC threading issues.

- Adds a SingleThreadTaskRunner for WebRTC medium to allow jingle calls
- Replaces SequencedTaskRunner with SingleThreadTaskRunner for platform SingleThreadExecutor impl

Bug: 1122532
Change-Id: I611ef85ec96fbcad3eeb160fd74b9e688edfc5f8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2379727Reviewed-by: Alex Chau <alexchau@chromium.org>
Commit-Queue: Alex Chau <alexchau@chromium.org>
Auto-Submit: Himanshu Jaju <himanshujaju@chromium.org>
Cr-Commit-Position: refs/heads/master@{#802757}

chrome/services/sharing/nearby/nearby_connections.cc

@@ -7,6 +7,7 @@
 #include "base/files/file_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/post_task.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/nearby_sharing/logging/logging.h"
 #include "chrome/services/sharing/nearby/nearby_connections_conversions.h"
 #include "chrome/services/sharing/nearby/platform_v2/input_file.h"
@@ -91,7 +92,8 @@ NearbyConnections::NearbyConnections(
     std::unique_ptr<Core> core)
     : nearby_connections_(this, std::move(nearby_connections)),
       on_disconnect_(std::move(on_disconnect)),
-      core_(std::move(core)) {
+      core_(std::move(core)),
+      thread_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   nearby_connections_.set_disconnect_handler(base::BindOnce(
       &NearbyConnections::OnDisconnect, weak_ptr_factory_.GetWeakPtr()));
 
@@ -445,6 +447,11 @@ base::File NearbyConnections::ExtractOutputFile(int64_t payload_id) {
   return file;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+NearbyConnections::GetThreadTaskRunner() {
+  return thread_task_runner_;
+}
+
 }  // namespace connections
 }  // namespace nearby
 }  // namespace location

chrome/services/sharing/nearby/nearby_connections.h

@@ -13,6 +13,7 @@
 #include "base/files/file.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/task/post_task.h"
 #include "base/thread_annotations.h"
@@ -111,6 +112,9 @@ class NearbyConnections : public mojom::NearbyConnections {
   // Returns the file associated with |payload_id| for OutputFile.
   base::File ExtractOutputFile(int64_t payload_id);
 
+  // Returns the task runner for the thread that created |this|.
+  scoped_refptr<base::SingleThreadTaskRunner> GetThreadTaskRunner();
+
  private:
   void OnDisconnect();
 
@@ -142,6 +146,8 @@ class NearbyConnections : public mojom::NearbyConnections {
   base::flat_map<int64_t, base::File> output_file_map_
       GUARDED_BY(output_file_lock_);
 
+  scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
+
   base::WeakPtrFactory<NearbyConnections> weak_ptr_factory_{this};
 };
 

chrome/services/sharing/nearby/platform.cc

@@ -53,7 +53,9 @@ int GetCurrentTid() {
 std::unique_ptr<SubmittableExecutor>
 ImplementationPlatform::CreateSingleThreadExecutor() {
   return std::make_unique<chrome::SubmittableExecutor>(
-      base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()}));
+      base::ThreadPool::CreateSingleThreadTaskRunner(
+          {base::MayBlock()},
+          base::SingleThreadTaskRunnerThreadMode::DEDICATED));
 }
 
 std::unique_ptr<SubmittableExecutor>
@@ -175,8 +177,9 @@ std::unique_ptr<WebRtcMedium> ImplementationPlatform::CreateWebRtcMedium() {
   if (!socket_manager || !mdns_responder || !ice_config_fetcher || !messenger)
     return nullptr;
 
-  return std::make_unique<chrome::WebRtcMedium>(socket_manager, mdns_responder,
-                                                ice_config_fetcher, messenger);
+  return std::make_unique<chrome::WebRtcMedium>(
+      socket_manager, mdns_responder, ice_config_fetcher, messenger,
+      connections.GetThreadTaskRunner());
 }
 
 std::unique_ptr<Mutex> ImplementationPlatform::CreateMutex(Mutex::Mode mode) {

chrome/services/sharing/nearby/platform_v2/webrtc.cc

@@ -159,16 +159,26 @@ WebRtcMedium::WebRtcMedium(
     network::mojom::P2PSocketManager* socket_manager,
     network::mojom::MdnsResponder* mdns_responder,
     sharing::mojom::IceConfigFetcher* ice_config_fetcher,
-    sharing::mojom::WebRtcSignalingMessenger* webrtc_signaling_messenger)
+    sharing::mojom::WebRtcSignalingMessenger* webrtc_signaling_messenger,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : p2p_socket_manager_(socket_manager),
       mdns_responder_(mdns_responder),
       ice_config_fetcher_(ice_config_fetcher),
-      webrtc_signaling_messenger_(webrtc_signaling_messenger) {}
+      webrtc_signaling_messenger_(webrtc_signaling_messenger),
+      task_runner_(std::move(task_runner)) {}
 WebRtcMedium::~WebRtcMedium() = default;
 
 void WebRtcMedium::CreatePeerConnection(
     webrtc::PeerConnectionObserver* observer,
     PeerConnectionCallback callback) {
+  task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&WebRtcMedium::FetchIceServers,
+                                weak_ptr_factory_.GetWeakPtr(), observer,
+                                std::move(callback)));
+}
+
+void WebRtcMedium::FetchIceServers(webrtc::PeerConnectionObserver* observer,
+                                   PeerConnectionCallback callback) {
   ice_config_fetcher_->GetIceServers(base::BindOnce(
       &WebRtcMedium::OnIceServersFetched, weak_ptr_factory_.GetWeakPtr(),
       observer, std::move(callback)));

chrome/services/sharing/nearby/platform_v2/webrtc.h

@@ -9,6 +9,7 @@
 
 #include <memory>
 
+#include "base/single_thread_task_runner.h"
 #include "chrome/services/sharing/public/mojom/webrtc.mojom.h"
 #include "chrome/services/sharing/public/mojom/webrtc_signaling_messenger.mojom.h"
 #include "services/network/public/mojom/mdns_responder.mojom.h"
@@ -32,7 +33,8 @@ class WebRtcMedium : public api::WebRtcMedium {
       network::mojom::P2PSocketManager* socket_manager,
       network::mojom::MdnsResponder* mdns_responder,
       sharing::mojom::IceConfigFetcher* ice_config_fetcher,
-      sharing::mojom::WebRtcSignalingMessenger* webrtc_signaling_messenger);
+      sharing::mojom::WebRtcSignalingMessenger* webrtc_signaling_messenger,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~WebRtcMedium() override;
 
   // api::WebRtcMedium:
@@ -42,6 +44,8 @@ class WebRtcMedium : public api::WebRtcMedium {
       absl::string_view self_id) override;
 
  private:
+  void FetchIceServers(webrtc::PeerConnectionObserver* observer,
+                       PeerConnectionCallback callback);
   void OnIceServersFetched(
       webrtc::PeerConnectionObserver* observer,
       PeerConnectionCallback callback,
@@ -54,6 +58,8 @@ class WebRtcMedium : public api::WebRtcMedium {
 
   std::unique_ptr<sharing::IpcPacketSocketFactory> socket_factory_;
 
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
   base::WeakPtrFactory<WebRtcMedium> weak_ptr_factory_{this};
 };
 

chrome/services/sharing/nearby/platform_v2/webrtc_test.cc

@@ -50,7 +50,8 @@ class WebRtcMediumTest : public ::testing::Test {
         webrtc_medium_(socket_manager_.get(),
                        mdns_responder_.get(),
                        ice_config_fetcher_.get(),
-                       messenger_.get()) {}
+                       messenger_.get(),
+                       base::ThreadTaskRunnerHandle::Get()) {}
 
   ~WebRtcMediumTest() override {
     // Let libjingle threads finish.