Update sink wants with ranges for both pixel count and frame rate.

webrtc/media/base/videobroadcaster_unittest.cc

Index: webrtc/media/base/videobroadcaster_unittest.cc
diff --git a/webrtc/media/base/videobroadcaster_unittest.cc b/webrtc/media/base/videobroadcaster_unittest.cc
index 5274868204589856369a9a1a46a9b41c68c37b7c..467d8868e33fd79777264a7703f6fdee7b544206 100644
--- a/webrtc/media/base/videobroadcaster_unittest.cc
+++ b/webrtc/media/base/videobroadcaster_unittest.cc
@@ -10,14 +10,44 @@
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/api/video/video_frame.h"
-#include "webrtc/base/gunit.h"
 #include "webrtc/media/base/fakevideorenderer.h"
 #include "webrtc/media/base/videobroadcaster.h"
+#include "webrtc/test/gtest.h"
 
 using rtc::VideoBroadcaster;
 using rtc::VideoSinkWants;
 using cricket::FakeVideoRenderer;
 
+namespace test {
+namespace {
+void ExpectEqualSinkWantsValueRange(const VideoSinkWants::Range range1,
+                                    const VideoSinkWants::Range range2) {
+  EXPECT_EQ(range1.min, range2.min);
+  EXPECT_EQ(range1.target, range2.target);
+  EXPECT_EQ(range1.max, range2.max);
+}
+
+void ExpectEqualSinkWants(const VideoSinkWants& wants1,
+                          const VideoSinkWants& wants2) {
+  EXPECT_EQ(wants1.rotation_applied, wants2.rotation_applied);
+  EXPECT_EQ(wants1.black_frames, wants2.black_frames);
+
+  if (wants1.pixel_count && wants2.pixel_count) {
+    ExpectEqualSinkWantsValueRange(*wants1.pixel_count, *wants2.pixel_count);
+  } else {
+    EXPECT_EQ(static_cast<bool>(wants1.pixel_count),
+              static_cast<bool>(wants2.pixel_count));
+  }
+
+  if (wants1.framerate_fps_ && wants2.framerate_fps_) {
+    ExpectEqualSinkWantsValueRange(*wants1.framerate_fps_,
+                                   *wants2.framerate_fps_);
+  } else {
+    EXPECT_EQ(static_cast<bool>(wants1.framerate_fps_),
+              static_cast<bool>(wants2.framerate_fps_));
+  }
+}
+}
 
 TEST(VideoBroadcasterTest, frame_wanted) {
   VideoBroadcaster broadcaster;
@@ -85,46 +115,111 @@ TEST(VideoBroadcasterTest, AppliesRotationIfAnySinkWantsRotationApplied) {
   EXPECT_FALSE(broadcaster.wants().rotation_applied);
 }
 
-TEST(VideoBroadcasterTest, AppliesMinOfSinkWantsMaxPixelCount) {
+TEST(VideoBroadcasterTest, MergedSinkWantsRespectsBounds) {
   VideoBroadcaster broadcaster;
-  EXPECT_TRUE(!broadcaster.wants().max_pixel_count);
+  EXPECT_FALSE(static_cast<bool>(broadcaster.wants().pixel_count));
 
   FakeVideoRenderer sink1;
   VideoSinkWants wants1;
-  wants1.max_pixel_count = rtc::Optional<int>(1280 * 720);
-
+  wants1.pixel_count.emplace(VideoSinkWants::Range(100, 200, 300));
   broadcaster.AddOrUpdateSink(&sink1, wants1);
-  EXPECT_EQ(1280 * 720, *broadcaster.wants().max_pixel_count);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
 
   FakeVideoRenderer sink2;
   VideoSinkWants wants2;
-  wants2.max_pixel_count = rtc::Optional<int>(640 * 360);
+  // Min above sink1, target below, max below. New range overrides all values.
+  wants2.pixel_count.emplace(VideoSinkWants::Range(110, 190, 290));
   broadcaster.AddOrUpdateSink(&sink2, wants2);
-  EXPECT_EQ(640 * 360, *broadcaster.wants().max_pixel_count);
+  ExpectEqualSinkWants(wants2, broadcaster.wants());
+
+  FakeVideoRenderer sink3;
+  VideoSinkWants wants3;
+  // Min below sink1, target above, max above. New values at bottom of pile.
+  wants3.pixel_count.emplace(VideoSinkWants::Range(90, 210, 310));
+  broadcaster.AddOrUpdateSink(&sink3, wants3);
+  ExpectEqualSinkWants(wants2, broadcaster.wants());
 
+  // Removes sink2, sink1 should rule again.
   broadcaster.RemoveSink(&sink2);
-  EXPECT_EQ(1280 * 720, *broadcaster.wants().max_pixel_count);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
+
+  // Removes sink1, sink3 is only one left.
+  broadcaster.RemoveSink(&sink1);
+  ExpectEqualSinkWants(wants3, broadcaster.wants());
+
+  // None left alive.
+  broadcaster.RemoveSink(&sink3);
+  EXPECT_FALSE(static_cast<bool>(broadcaster.wants().pixel_count));
 }
 
-TEST(VideoBroadcasterTest, AppliesMinOfSinkWantsMaxAndTargetPixelCount) {
+TEST(VideoBroadcasterTest, MergedSinkWantsRespectsHighMin) {
   VideoBroadcaster broadcaster;
-  EXPECT_TRUE(!broadcaster.wants().target_pixel_count);
+  EXPECT_FALSE(static_cast<bool>(broadcaster.wants().pixel_count));
 
   FakeVideoRenderer sink1;
   VideoSinkWants wants1;
-  wants1.target_pixel_count = rtc::Optional<int>(1280 * 720);
+  wants1.pixel_count.emplace(VideoSinkWants::Range(100, 200, 300));
+  broadcaster.AddOrUpdateSink(&sink1, wants1);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
+
+  FakeVideoRenderer sink2;
+  VideoSinkWants wants2;
+  // Min above wants1, so overrides. Goes above max of sink 1, so will be capped
+  // at sink1.max.
+  wants2.pixel_count.emplace(VideoSinkWants::Range(310, 400, 500));
+  broadcaster.AddOrUpdateSink(&sink2, wants2);
+  VideoSinkWants expected_merged_wants;
+  expected_merged_wants.pixel_count.emplace(
+      VideoSinkWants::Range(300, 300, 300));
+  ExpectEqualSinkWants(expected_merged_wants, broadcaster.wants());
+
+  // Removes sink2, sink1 should rule again.
+  broadcaster.RemoveSink(&sink2);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
+
+  FakeVideoRenderer sink3;
+  VideoSinkWants wants3;
+  // Max above wants1, so overrides. Goes below target of sink 1, overriding
+  // that, but keeps min.
+  wants3.pixel_count.emplace(VideoSinkWants::Range(210, 300, 400));
+  broadcaster.AddOrUpdateSink(&sink3, wants3);
+  expected_merged_wants.pixel_count.emplace(
+      VideoSinkWants::Range(210, 210, 300));
+  ExpectEqualSinkWants(expected_merged_wants, broadcaster.wants());
+}
 
+TEST(VideoBroadcasterTest, MergedSinkWantsRespectsLowMax) {
+  VideoBroadcaster broadcaster;
+  EXPECT_FALSE(static_cast<bool>(broadcaster.wants().pixel_count));
+
+  FakeVideoRenderer sink1;
+  VideoSinkWants wants1;
+  wants1.pixel_count.emplace(VideoSinkWants::Range(100, 200, 300));
   broadcaster.AddOrUpdateSink(&sink1, wants1);
-  EXPECT_EQ(1280 * 720, *broadcaster.wants().target_pixel_count);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
 
   FakeVideoRenderer sink2;
   VideoSinkWants wants2;
-  wants2.target_pixel_count = rtc::Optional<int>(640 * 360);
+  // Max below wants1, so overrides. Goes below min of sink 1, so will be capped
+  // at sink2.max. Target then has to follow min.
+  wants2.pixel_count.emplace(VideoSinkWants::Range(40, 50, 90));
   broadcaster.AddOrUpdateSink(&sink2, wants2);
-  EXPECT_EQ(640 * 360, *broadcaster.wants().target_pixel_count);
+  VideoSinkWants expected_wants;
+  expected_wants.pixel_count.emplace(VideoSinkWants::Range(90, 90, 90));
+  ExpectEqualSinkWants(expected_wants, broadcaster.wants());
 
+  // Removes sink2, sink1 should rule again.
   broadcaster.RemoveSink(&sink2);
-  EXPECT_EQ(1280 * 720, *broadcaster.wants().target_pixel_count);
+  ExpectEqualSinkWants(wants1, broadcaster.wants());
+
+  FakeVideoRenderer sink3;
+  VideoSinkWants wants3;
+  // Max below wants1, so overrides. Goes below target of sink 1, so will cap
+  // the target but not affect the min.
+  wants3.pixel_count.emplace(VideoSinkWants::Range(90, 150, 150));
+  broadcaster.AddOrUpdateSink(&sink3, wants3);
+  expected_wants.pixel_count.emplace(VideoSinkWants::Range(100, 150, 150));
+  ExpectEqualSinkWants(expected_wants, broadcaster.wants());
 }
 
 TEST(VideoBroadcasterTest, SinkWantsBlackFrames) {
@@ -168,3 +263,5 @@ TEST(VideoBroadcasterTest, SinkWantsBlackFrames) {
   EXPECT_TRUE(sink2.black_frame());
   EXPECT_EQ(30, sink2.timestamp_us());
 }
+
+}  // namespace test