Add tests for FrameBuffer3 and SyncDecoding in PC Integration Tests

Change-Id: I04ae6a694599a535347c29706e5ad40cba58155b
Bug: webrtc:13672
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/251721
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36104}

pc/BUILD.gn

@@ -1989,6 +1989,7 @@ if (rtc_include_tests && !build_with_chromium) {
       "../rtc_base:timeutils",
       "../rtc_base/synchronization:mutex",
       "../rtc_base/task_utils:pending_task_safety_flag",
+      "../rtc_base/task_utils:repeating_task",
       "../rtc_base/task_utils:to_queued_task",
       "../rtc_base/third_party/base64",
       "../rtc_base/third_party/sigslot",

pc/peer_connection_integrationtest.cc

@@ -96,10 +96,12 @@ namespace {
 
 class PeerConnectionIntegrationTest
     : public PeerConnectionIntegrationBaseTest,
-      public ::testing::WithParamInterface<SdpSemantics> {
+      public ::testing::WithParamInterface<
+          std::tuple<SdpSemantics, std::string>> {
  protected:
   PeerConnectionIntegrationTest()
-      : PeerConnectionIntegrationBaseTest(GetParam()) {}
+      : PeerConnectionIntegrationBaseTest(std::get<0>(GetParam()),
+                                          std::get<1>(GetParam())) {}
 };
 
 // Fake clock must be set before threads are started to prevent race on
@@ -3516,15 +3518,21 @@ TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
   }
 }
 
-INSTANTIATE_TEST_SUITE_P(PeerConnectionIntegrationTest,
-                         PeerConnectionIntegrationTest,
-                         Values(SdpSemantics::kPlanB,
-                                SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(
+    PeerConnectionIntegrationTest,
+    PeerConnectionIntegrationTest,
+    Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
+            Values("WebRTC-FrameBuffer3/arm:FrameBuffer2/",
+                   "WebRTC-FrameBuffer3/arm:FrameBuffer3/",
+                   "WebRTC-FrameBuffer3/arm:SyncDecoding/")));
 
-INSTANTIATE_TEST_SUITE_P(PeerConnectionIntegrationTest,
-                         PeerConnectionIntegrationTestWithFakeClock,
-                         Values(SdpSemantics::kPlanB,
-                                SdpSemantics::kUnifiedPlan));
+INSTANTIATE_TEST_SUITE_P(
+    PeerConnectionIntegrationTest,
+    PeerConnectionIntegrationTestWithFakeClock,
+    Combine(Values(SdpSemantics::kPlanB, SdpSemantics::kUnifiedPlan),
+            Values("WebRTC-FrameBuffer3/arm:FrameBuffer2/",
+                   "WebRTC-FrameBuffer3/arm:FrameBuffer3/",
+                   "WebRTC-FrameBuffer3/arm:SyncDecoding/")));
 
 // Tests that verify interoperability between Plan B and Unified Plan
 // PeerConnections.

pc/test/integration_test_helpers.cc

@@ -56,4 +56,46 @@ int FindFirstMediaStatsIndexByKind(
   return -1;
 }
 
+TaskQueueMetronome::TaskQueueMetronome(TaskQueueFactory* factory,
+                                       TimeDelta tick_period)
+    : tick_period_(tick_period),
+      queue_(factory->CreateTaskQueue("MetronomeQueue",
+                                      TaskQueueFactory::Priority::HIGH)) {
+  tick_task_ = RepeatingTaskHandle::Start(queue_.Get(), [this] {
+    MutexLock lock(&mutex_);
+    for (auto* listener : listeners_) {
+      listener->OnTickTaskQueue()->PostTask(
+          ToQueuedTask([listener] { listener->OnTick(); }));
+    }
+    return tick_period_;
+  });
+}
+
+TaskQueueMetronome::~TaskQueueMetronome() {
+  RTC_DCHECK(listeners_.empty());
+  rtc::Event stop_event;
+  queue_.PostTask([this, &stop_event] {
+    tick_task_.Stop();
+    stop_event.Set();
+  });
+  stop_event.Wait(1000);
+}
+
+void TaskQueueMetronome::AddListener(TickListener* listener) {
+  MutexLock lock(&mutex_);
+  auto [it, inserted] = listeners_.insert(listener);
+  RTC_DCHECK(inserted);
+}
+
+void TaskQueueMetronome::RemoveListener(TickListener* listener) {
+  MutexLock lock(&mutex_);
+  auto it = listeners_.find(listener);
+  RTC_DCHECK(it != listeners_.end());
+  listeners_.erase(it);
+}
+
+TimeDelta TaskQueueMetronome::TickPeriod() const {
+  return tick_period_;
+}
+
 }  // namespace webrtc

pc/test/integration_test_helpers.h

@@ -95,6 +95,7 @@
 #include "pc/test/mock_peer_connection_observers.h"
 #include "pc/video_track_source.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/event.h"
 #include "rtc_base/fake_clock.h"
 #include "rtc_base/fake_mdns_responder.h"
 #include "rtc_base/fake_network.h"
@@ -111,9 +112,11 @@
 #include "rtc_base/socket_address.h"
 #include "rtc_base/ssl_stream_adapter.h"
 #include "rtc_base/task_utils/pending_task_safety_flag.h"
+#include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/task_utils/to_queued_task.h"
 #include "rtc_base/test_certificate_verifier.h"
 #include "rtc_base/thread.h"
+#include "rtc_base/thread_annotations.h"
 #include "rtc_base/time_utils.h"
 #include "rtc_base/virtual_socket_server.h"
 #include "system_wrappers/include/metrics.h"
@@ -172,6 +175,24 @@ int FindFirstMediaStatsIndexByKind(
     const std::vector<const webrtc::RTCMediaStreamTrackStats*>&
         media_stats_vec);
 
+class TaskQueueMetronome : public webrtc::Metronome {
+ public:
+  TaskQueueMetronome(TaskQueueFactory* factory, TimeDelta tick_period);
+  ~TaskQueueMetronome() override;
+
+  // webrtc::Metronome implementation.
+  void AddListener(TickListener* listener) override;
+  void RemoveListener(TickListener* listener) override;
+  TimeDelta TickPeriod() const override;
+
+ private:
+  Mutex mutex_;
+  const TimeDelta tick_period_;
+  std::set<TickListener*> listeners_ RTC_GUARDED_BY(mutex_);
+  RepeatingTaskHandle tick_task_;
+  rtc::TaskQueue queue_;
+};
+
 class SignalingMessageReceiver {
  public:
   virtual void ReceiveSdpMessage(SdpType type, const std::string& msg) = 0;
@@ -735,6 +756,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
     pc_factory_dependencies.task_queue_factory =
         webrtc::CreateDefaultTaskQueueFactory();
     pc_factory_dependencies.trials = std::make_unique<FieldTrialBasedConfig>();
+    pc_factory_dependencies.metronome = std::make_unique<TaskQueueMetronome>(
+        pc_factory_dependencies.task_queue_factory.get(), TimeDelta::Millis(8));
     cricket::MediaEngineDependencies media_deps;
     media_deps.task_queue_factory =
         pc_factory_dependencies.task_queue_factory.get();