Add TaskQueueStdlib experiment.

Bug: webrtc:14389
Change-Id: I23c6e0ae675748ec35a99c334104dd2654995a33
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265802
Commit-Queue: Ali Tofigh <alito@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37888}

api/create_peerconnection_factory.cc

@@ -40,19 +40,20 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
     rtc::scoped_refptr<AudioProcessing> audio_processing,
     AudioFrameProcessor* audio_frame_processor,
     std::unique_ptr<FieldTrialsView> field_trials) {
+  if (!field_trials) {
+    field_trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
+  }
+
   PeerConnectionFactoryDependencies dependencies;
   dependencies.network_thread = network_thread;
   dependencies.worker_thread = worker_thread;
   dependencies.signaling_thread = signaling_thread;
-  dependencies.task_queue_factory = CreateDefaultTaskQueueFactory();
+  dependencies.task_queue_factory =
+      CreateDefaultTaskQueueFactory(field_trials.get());
   dependencies.call_factory = CreateCallFactory();
   dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>(
       dependencies.task_queue_factory.get());
-  if (field_trials) {
   dependencies.trials = std::move(field_trials);
-  } else {
-    dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
-  }
 
   if (network_thread) {
     // TODO(bugs.webrtc.org/13145): Add an rtc::SocketFactory* argument.

api/task_queue/BUILD.gn

@@ -61,7 +61,9 @@ rtc_library("task_queue_test") {
     ]
   } else {
     deps = [
+      ":default_task_queue_factory",
       ":task_queue",
+      "../../api:field_trials_view",
       "../../api/units:time_delta",
       "../../rtc_base:refcount",
       "../../rtc_base:rtc_event",
@@ -81,11 +83,26 @@ rtc_library("default_task_queue_factory") {
     poisonous = [ "default_task_queue" ]
   }
   sources = [ "default_task_queue_factory.h" ]
-  deps = [ ":task_queue" ]
+  deps = [
+    ":task_queue",
+    "../../api:field_trials_view",
+    "../../rtc_base/memory:always_valid_pointer",
+  ]
 
   if (rtc_enable_libevent) {
+    if (is_android) {
+      sources +=
+          [ "default_task_queue_factory_stdlib_or_libevent_experiment.cc" ]
+      deps += [
+        "../../api/transport:field_trial_based_config",
+        "../../rtc_base:logging",
+        "../../rtc_base:rtc_task_queue_libevent",
+        "../../rtc_base:rtc_task_queue_stdlib",
+      ]
+    } else {
       sources += [ "default_task_queue_factory_libevent.cc" ]
       deps += [ "../../rtc_base:rtc_task_queue_libevent" ]
+    }
   } else if (is_mac || is_ios) {
     sources += [ "default_task_queue_factory_gcd.cc" ]
     deps += [ "../../rtc_base:rtc_task_queue_gcd" ]

api/task_queue/default_task_queue_factory.h

@@ -12,11 +12,13 @@
 
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 
 namespace webrtc {
 
-std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory();
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials = nullptr);
 
 }  // namespace webrtc
 

api/task_queue/default_task_queue_factory_gcd.cc

@@ -9,12 +9,14 @@
  */
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "rtc_base/task_queue_gcd.h"
 
 namespace webrtc {
 
-std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials) {
   return CreateTaskQueueGcdFactory();
 }
 

api/task_queue/default_task_queue_factory_libevent.cc

@@ -9,12 +9,14 @@
  */
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "rtc_base/task_queue_libevent.h"
 
 namespace webrtc {
 
-std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials) {
   return CreateTaskQueueLibeventFactory();
 }
 

api/task_queue/default_task_queue_factory_stdlib.cc

@@ -9,12 +9,14 @@
  */
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "rtc_base/task_queue_stdlib.h"
 
 namespace webrtc {
 
-std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials) {
   return CreateTaskQueueStdlibFactory();
 }
 

api/task_queue/default_task_queue_factory_stdlib_or_libevent_experiment.cc

@@ -0,0 +1,38 @@
+/*
+ *  Copyright 2022 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <memory>
+
+#include "api/field_trials_view.h"
+#include "api/task_queue/task_queue_factory.h"
+#include "api/transport/field_trial_based_config.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/memory/always_valid_pointer.h"
+#include "rtc_base/task_queue_libevent.h"
+#include "rtc_base/task_queue_stdlib.h"
+
+namespace webrtc {
+
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials_view) {
+  AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig> field_trials(
+      field_trials_view);
+  if (field_trials->IsEnabled("WebRTC-TaskQueue-ReplaceLibeventWithStdlib")) {
+    RTC_LOG(LS_INFO) << "WebRTC-TaskQueue-ReplaceLibeventWithStdlib: "
+                     << "using TaskQueueStdlibFactory.";
+    return CreateTaskQueueStdlibFactory();
+  }
+
+  RTC_LOG(LS_INFO) << "WebRTC-TaskQueue-ReplaceLibeventWithStdlib: "
+                   << "using TaskQueueLibeventFactory.";
+  return CreateTaskQueueLibeventFactory();
+}
+
+}  // namespace webrtc

api/task_queue/default_task_queue_factory_win.cc

@@ -9,12 +9,14 @@
  */
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "rtc_base/task_queue_win.h"
 
 namespace webrtc {
 
-std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory() {
+std::unique_ptr<TaskQueueFactory> CreateDefaultTaskQueueFactory(
+    const FieldTrialsView* field_trials) {
   return CreateTaskQueueWinFactory();
 }
 

api/task_queue/task_queue_test.cc

@@ -13,6 +13,7 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/strings/string_view.h"
+#include "api/task_queue/default_task_queue_factory.h"
 #include "api/units/time_delta.h"
 #include "rtc_base/event.h"
 #include "rtc_base/ref_counter.h"
@@ -29,13 +30,13 @@ std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(
 }
 
 TEST_P(TaskQueueTest, Construct) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   auto queue = CreateTaskQueue(factory, "Construct");
   EXPECT_FALSE(queue->IsCurrent());
 }
 
 TEST_P(TaskQueueTest, PostAndCheckCurrent) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event event;
   auto queue = CreateTaskQueue(factory, "PostAndCheckCurrent");
 
@@ -53,7 +54,7 @@ TEST_P(TaskQueueTest, PostAndCheckCurrent) {
 }
 
 TEST_P(TaskQueueTest, PostCustomTask) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event ran;
   auto queue = CreateTaskQueue(factory, "PostCustomImplementation");
 
@@ -72,7 +73,7 @@ TEST_P(TaskQueueTest, PostCustomTask) {
 }
 
 TEST_P(TaskQueueTest, PostDelayedZero) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event event;
   auto queue = CreateTaskQueue(factory, "PostDelayedZero");
 
@@ -81,7 +82,7 @@ TEST_P(TaskQueueTest, PostDelayedZero) {
 }
 
 TEST_P(TaskQueueTest, PostFromQueue) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event event;
   auto queue = CreateTaskQueue(factory, "PostFromQueue");
 
@@ -91,7 +92,7 @@ TEST_P(TaskQueueTest, PostFromQueue) {
 }
 
 TEST_P(TaskQueueTest, PostDelayed) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event event;
   auto queue =
       CreateTaskQueue(factory, "PostDelayed", TaskQueueFactory::Priority::HIGH);
@@ -113,7 +114,7 @@ TEST_P(TaskQueueTest, PostDelayed) {
 }
 
 TEST_P(TaskQueueTest, PostMultipleDelayed) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   auto queue = CreateTaskQueue(factory, "PostMultipleDelayed");
 
   std::vector<rtc::Event> events(100);
@@ -132,7 +133,7 @@ TEST_P(TaskQueueTest, PostMultipleDelayed) {
 }
 
 TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event run;
   rtc::Event deleted;
   auto queue = CreateTaskQueue(factory, "PostDelayedAfterDestruct");
@@ -147,7 +148,7 @@ TEST_P(TaskQueueTest, PostDelayedAfterDestruct) {
 }
 
 TEST_P(TaskQueueTest, PostAndReuse) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   rtc::Event event;
   auto post_queue = CreateTaskQueue(factory, "PostQueue");
   auto reply_queue = CreateTaskQueue(factory, "ReplyQueue");
@@ -203,7 +204,7 @@ TEST_P(TaskQueueTest, PostALot) {
     rtc::Event event_;
   };
 
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   static constexpr int kTaskCount = 0xffff;
   rtc::Event posting_done;
   BlockingCounter all_destroyed(kTaskCount);
@@ -247,7 +248,7 @@ TEST_P(TaskQueueTest, PostALot) {
 // unit test, run it under TSan or some other tool that is able to
 // directly detect data races.
 TEST_P(TaskQueueTest, PostTwoWithSharedUnprotectedState) {
-  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()();
+  std::unique_ptr<webrtc::TaskQueueFactory> factory = GetParam()(nullptr);
   struct SharedState {
     // First task will set this value to 1 and second will assert it.
     int state = 0;

api/task_queue/task_queue_test.h

@@ -13,6 +13,7 @@
 #include <functional>
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "test/gtest.h"
 
@@ -31,9 +32,9 @@ namespace webrtc {
 // INSTANTIATE_TEST_SUITE_P(My, TaskQueueTest, Values(CreateMyFactory));
 //
 // }  // namespace
-class TaskQueueTest : public ::testing::TestWithParam<
+class TaskQueueTest
-                          std::function<std::unique_ptr<TaskQueueFactory>()>> {
+    : public ::testing::TestWithParam<std::function<
-};
+          std::unique_ptr<TaskQueueFactory>(const FieldTrialsView*)>> {};
 
 }  // namespace webrtc
 

rtc_base/BUILD.gn

@@ -1752,6 +1752,7 @@ if (rtc_include_tests) {
         ":threading",
         ":timeutils",
         "../api:array_view",
+        "../api:field_trials_view",
         "../api:make_ref_counted",
         "../api/task_queue",
         "../api/task_queue:pending_task_safety_flag",

rtc_base/thread_unittest.cc

@@ -12,6 +12,7 @@
 
 #include <memory>
 
+#include "api/field_trials_view.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "api/task_queue/task_queue_test.h"
 #include "api/units/time_delta.h"
@@ -1138,11 +1139,16 @@ class ThreadFactory : public webrtc::TaskQueueFactory {
   }
 };
 
+std::unique_ptr<webrtc::TaskQueueFactory> CreateDefaultThreadFactory(
+    const webrtc::FieldTrialsView*) {
+  return std::make_unique<ThreadFactory>();
+}
+
 using ::webrtc::TaskQueueTest;
 
 INSTANTIATE_TEST_SUITE_P(RtcThread,
                          TaskQueueTest,
-                         ::testing::Values(std::make_unique<ThreadFactory>));
+                         ::testing::Values(CreateDefaultThreadFactory));
 
 }  // namespace
 }  // namespace rtc

rtc_tools/video_replay.cc

@@ -340,21 +340,22 @@ class RtpReplayer final {
   // Replay a rtp dump with an optional json configuration.
   static void Replay(const std::string& replay_config_path,
                      const std::string& rtp_dump_path) {
+    webrtc::RtcEventLogNull event_log;
+    Call::Config call_config(&event_log);
+    call_config.trials = new FieldTrialBasedConfig();
+
     std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory =
-        webrtc::CreateDefaultTaskQueueFactory();
+        webrtc::CreateDefaultTaskQueueFactory(call_config.trials);
     auto worker_thread = task_queue_factory->CreateTaskQueue(
         "worker_thread", TaskQueueFactory::Priority::NORMAL);
     rtc::Event sync_event(/*manual_reset=*/false,
                           /*initially_signalled=*/false);
-    webrtc::RtcEventLogNull event_log;
-    Call::Config call_config(&event_log);
     call_config.task_queue_factory = task_queue_factory.get();
-    call_config.trials = new FieldTrialBasedConfig();
-    std::unique_ptr<Call> call;
-    std::unique_ptr<StreamState> stream_state;
 
     // Creation of the streams must happen inside a task queue because it is
     // resued as a worker thread.
+    std::unique_ptr<Call> call;
+    std::unique_ptr<StreamState> stream_state;
     worker_thread->PostTask([&]() {
       call.reset(Call::Create(call_config));
 

sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm

@@ -173,8 +173,9 @@
     if (webrtc::field_trial::IsEnabled("WebRTC-Network-UseNWPathMonitor")) {
       dependencies.network_monitor_factory = webrtc::CreateNetworkMonitorFactory();
     }
-    dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
     dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
+    dependencies.task_queue_factory =
+        webrtc::CreateDefaultTaskQueueFactory(dependencies.trials.get());
     cricket::MediaEngineDependencies media_deps;
     media_deps.adm = std::move(audioDeviceModule);
     media_deps.task_queue_factory = dependencies.task_queue_factory.get();