1 // Copyright 2017 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_video_content.h"
6
7 #include <cmath>
8 #include <string>
9
10 #include "media/base/limits.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12 #include "third_party/blink/public/platform/modules/mediastream/web_platform_media_stream_source.h"
13 #include "third_party/blink/renderer/modules/mediastream/media_stream_constraints_util.h"
14 #include "third_party/blink/renderer/modules/mediastream/mock_constraint_factory.h"
15 #include "third_party/blink/renderer/platform/mediastream/media_constraints.h"
16
17 namespace blink {
18
19 // To avoid symbol collisions in jumbo builds.
20 namespace media_stream_constraints_util_video_content_test {
21
22 namespace {
23
24 const double kDefaultScreenCastAspectRatio =
25 static_cast<double>(kDefaultScreenCastWidth) / kDefaultScreenCastHeight;
26
CheckNonResolutionDefaults(const VideoCaptureSettings & result)27 void CheckNonResolutionDefaults(const VideoCaptureSettings& result) {
28 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
29 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
30 EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
31 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
32 EXPECT_EQ(std::string(), result.device_id());
33 EXPECT_FALSE(result.min_frame_rate().has_value());
34 }
35
CheckNonFrameRateDefaults(const VideoCaptureSettings & result)36 void CheckNonFrameRateDefaults(const VideoCaptureSettings& result) {
37 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
38 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
39 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
40 EXPECT_EQ(std::string(), result.device_id());
41 }
42
CheckTrackAdapterSettingsEqualsFormat(const VideoCaptureSettings & result,double frame_rate=0.0)43 void CheckTrackAdapterSettingsEqualsFormat(const VideoCaptureSettings& result,
44 double frame_rate = 0.0) {
45 // For content capture, resolution and frame rate should always be the same
46 // for source and track.
47 EXPECT_TRUE(result.track_adapter_settings().target_size().has_value());
48 EXPECT_EQ(result.Width(), result.track_adapter_settings().target_width());
49 EXPECT_EQ(result.Height(), result.track_adapter_settings().target_height());
50 EXPECT_EQ(frame_rate, result.track_adapter_settings().max_frame_rate());
51 }
52
CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(const VideoCaptureSettings & result,double frame_rate=0.0)53 void CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(
54 const VideoCaptureSettings& result,
55 double frame_rate = 0.0) {
56 EXPECT_EQ(
57 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension,
58 result.track_adapter_settings().min_aspect_ratio());
59 EXPECT_EQ(
60 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
61 result.track_adapter_settings().max_aspect_ratio());
62 CheckTrackAdapterSettingsEqualsFormat(result, frame_rate);
63 }
64
65 } // namespace
66
67 class MediaStreamConstraintsUtilVideoContentTest : public testing::Test {
68 protected:
SelectSettings(mojom::MediaStreamType stream_type=mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE)69 VideoCaptureSettings SelectSettings(
70 mojom::MediaStreamType stream_type =
71 mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE) {
72 MediaConstraints constraints = constraint_factory_.CreateMediaConstraints();
73 return SelectSettingsVideoContentCapture(constraints, stream_type,
74 kDefaultScreenCastWidth,
75 kDefaultScreenCastHeight);
76 }
77
78 MockConstraintFactory constraint_factory_;
79 };
80
81 // The Unconstrained test checks the default selection criteria.
TEST_F(MediaStreamConstraintsUtilVideoContentTest,Unconstrained)82 TEST_F(MediaStreamConstraintsUtilVideoContentTest, Unconstrained) {
83 constraint_factory_.Reset();
84 auto result = SelectSettings();
85
86 // All settings should have default values.
87 EXPECT_TRUE(result.HasValue());
88 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
89 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
90 CheckNonResolutionDefaults(result);
91 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
92 }
93
94 // The "Overconstrained" tests verify that failure of any single required
95 // constraint results in failure to select a candidate.
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnHeight)96 TEST_F(MediaStreamConstraintsUtilVideoContentTest, OverconstrainedOnHeight) {
97 constraint_factory_.Reset();
98 constraint_factory_.basic().height.SetExact(kMaxScreenCastDimension + 1);
99 auto result = SelectSettings();
100 EXPECT_FALSE(result.HasValue());
101 EXPECT_EQ(constraint_factory_.basic().height.GetName(),
102 result.failed_constraint_name());
103
104 constraint_factory_.Reset();
105 constraint_factory_.basic().height.SetMin(kMaxScreenCastDimension + 1);
106 result = SelectSettings();
107 EXPECT_FALSE(result.HasValue());
108 EXPECT_EQ(constraint_factory_.basic().height.GetName(),
109 result.failed_constraint_name());
110
111 constraint_factory_.Reset();
112 constraint_factory_.basic().height.SetMax(kMinScreenCastDimension - 1);
113 result = SelectSettings();
114 EXPECT_FALSE(result.HasValue());
115 EXPECT_EQ(constraint_factory_.basic().height.GetName(),
116 result.failed_constraint_name());
117 }
118
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnWidth)119 TEST_F(MediaStreamConstraintsUtilVideoContentTest, OverconstrainedOnWidth) {
120 constraint_factory_.Reset();
121 constraint_factory_.basic().width.SetExact(kMaxScreenCastDimension + 1);
122 auto result = SelectSettings();
123 EXPECT_FALSE(result.HasValue());
124 EXPECT_EQ(constraint_factory_.basic().width.GetName(),
125 result.failed_constraint_name());
126
127 constraint_factory_.Reset();
128 constraint_factory_.basic().width.SetMin(kMaxScreenCastDimension + 1);
129 result = SelectSettings();
130 EXPECT_FALSE(result.HasValue());
131 EXPECT_EQ(constraint_factory_.basic().width.GetName(),
132 result.failed_constraint_name());
133
134 constraint_factory_.Reset();
135 constraint_factory_.basic().width.SetMax(kMinScreenCastDimension - 1);
136 result = SelectSettings();
137 EXPECT_FALSE(result.HasValue());
138 EXPECT_EQ(constraint_factory_.basic().width.GetName(),
139 result.failed_constraint_name());
140 }
141
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnAspectRatio)142 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
143 OverconstrainedOnAspectRatio) {
144 constraint_factory_.Reset();
145 constraint_factory_.basic().aspect_ratio.SetExact(123467890);
146 auto result = SelectSettings();
147 EXPECT_FALSE(result.HasValue());
148 EXPECT_EQ(constraint_factory_.basic().aspect_ratio.GetName(),
149 result.failed_constraint_name());
150
151 constraint_factory_.Reset();
152 constraint_factory_.basic().aspect_ratio.SetMin(123467890);
153 result = SelectSettings();
154 EXPECT_FALSE(result.HasValue());
155 EXPECT_EQ(constraint_factory_.basic().aspect_ratio.GetName(),
156 result.failed_constraint_name());
157
158 constraint_factory_.Reset();
159 constraint_factory_.basic().aspect_ratio.SetMax(0.00001);
160 result = SelectSettings();
161 EXPECT_FALSE(result.HasValue());
162 EXPECT_EQ(constraint_factory_.basic().aspect_ratio.GetName(),
163 result.failed_constraint_name());
164 }
165
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnFrameRate)166 TEST_F(MediaStreamConstraintsUtilVideoContentTest, OverconstrainedOnFrameRate) {
167 constraint_factory_.Reset();
168 constraint_factory_.basic().frame_rate.SetExact(kMaxScreenCastFrameRate +
169 0.1);
170 auto result = SelectSettings();
171 EXPECT_FALSE(result.HasValue());
172 EXPECT_EQ(constraint_factory_.basic().frame_rate.GetName(),
173 result.failed_constraint_name());
174
175 constraint_factory_.Reset();
176 constraint_factory_.basic().frame_rate.SetMin(kMaxScreenCastFrameRate + 0.1);
177 result = SelectSettings();
178 EXPECT_FALSE(result.HasValue());
179 EXPECT_EQ(constraint_factory_.basic().frame_rate.GetName(),
180 result.failed_constraint_name());
181
182 constraint_factory_.Reset();
183 constraint_factory_.basic().frame_rate.SetMax(-0.1);
184 result = SelectSettings();
185 EXPECT_FALSE(result.HasValue());
186 EXPECT_EQ(constraint_factory_.basic().frame_rate.GetName(),
187 result.failed_constraint_name());
188 }
189
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnInvalidResizeMode)190 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
191 OverconstrainedOnInvalidResizeMode) {
192 constraint_factory_.Reset();
193 constraint_factory_.basic().resize_mode.SetExact("invalid");
194 auto result = SelectSettings();
195 EXPECT_FALSE(result.HasValue());
196 EXPECT_EQ(constraint_factory_.basic().resize_mode.GetName(),
197 result.failed_constraint_name());
198 }
199
TEST_F(MediaStreamConstraintsUtilVideoContentTest,OverconstrainedOnEmptyResizeMode)200 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
201 OverconstrainedOnEmptyResizeMode) {
202 constraint_factory_.Reset();
203 constraint_factory_.basic().resize_mode.SetExact("");
204 auto result = SelectSettings();
205 EXPECT_FALSE(result.HasValue());
206 EXPECT_EQ(constraint_factory_.basic().resize_mode.GetName(),
207 result.failed_constraint_name());
208 }
209
210 // The "Mandatory" and "Ideal" tests check that various selection criteria work
211 // for each individual constraint in the basic constraint set.
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryDeviceID)212 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryDeviceID) {
213 const String kDeviceID = "Some ID";
214 constraint_factory_.Reset();
215 constraint_factory_.basic().device_id.SetExact(kDeviceID);
216 auto result = SelectSettings();
217 EXPECT_TRUE(result.HasValue());
218 EXPECT_EQ(kDeviceID.Utf8(), result.device_id());
219 // Other settings should have default values.
220 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
221 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
222 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
223 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
224 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
225 }
226
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealDeviceID)227 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealDeviceID) {
228 const String kDeviceID = "Some ID";
229 const String kIdealID = "Ideal ID";
230 Vector<String> device_ids(static_cast<size_t>(2));
231 device_ids[0] = kDeviceID;
232 device_ids[1] = kIdealID;
233 constraint_factory_.Reset();
234 constraint_factory_.basic().device_id.SetExact(device_ids);
235
236 Vector<String> ideal_id(static_cast<size_t>(1));
237 ideal_id[0] = kIdealID;
238 constraint_factory_.basic().device_id.SetIdeal(ideal_id);
239
240 auto result = SelectSettings();
241 EXPECT_TRUE(result.HasValue());
242 EXPECT_EQ(kIdealID.Utf8(), result.device_id());
243 // Other settings should have default values.
244 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
245 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
246 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
247 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
248 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
249 }
250
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryNoiseReduction)251 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryNoiseReduction) {
252 constraint_factory_.Reset();
253 const bool kNoiseReductionValues[] = {true, false};
254 for (auto noise_reduction : kNoiseReductionValues) {
255 constraint_factory_.basic().goog_noise_reduction.SetExact(noise_reduction);
256 auto result = SelectSettings();
257 EXPECT_TRUE(result.HasValue());
258 EXPECT_EQ(noise_reduction, result.noise_reduction());
259 // Other settings should have default values.
260 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
261 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
262 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
263 EXPECT_EQ(std::string(), result.device_id());
264 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
265 }
266 }
267
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealNoiseReduction)268 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealNoiseReduction) {
269 constraint_factory_.Reset();
270 const bool kNoiseReductionValues[] = {true, false};
271 for (auto noise_reduction : kNoiseReductionValues) {
272 constraint_factory_.basic().goog_noise_reduction.SetIdeal(noise_reduction);
273 auto result = SelectSettings();
274 EXPECT_TRUE(result.HasValue());
275 EXPECT_EQ(noise_reduction, result.noise_reduction());
276 // Other settings should have default values.
277 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
278 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
279 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
280 EXPECT_EQ(std::string(), result.device_id());
281 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
282 }
283 }
284
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryExactHeight)285 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactHeight) {
286 constraint_factory_.Reset();
287 const int kHeight = 1000;
288 constraint_factory_.basic().height.SetExact(kHeight);
289 auto result = SelectSettings();
290 EXPECT_TRUE(result.HasValue());
291 EXPECT_EQ(kHeight, result.Height());
292 // The algorithm tries to preserve the default aspect ratio.
293 EXPECT_EQ(std::round(kHeight * kDefaultScreenCastAspectRatio),
294 result.Width());
295 CheckNonResolutionDefaults(result);
296 EXPECT_EQ(1.0 / kHeight, result.track_adapter_settings().min_aspect_ratio());
297 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kHeight,
298 result.track_adapter_settings().max_aspect_ratio());
299 CheckTrackAdapterSettingsEqualsFormat(result);
300 }
301
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMinHeight)302 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinHeight) {
303 constraint_factory_.Reset();
304 const int kHeight = 2000;
305 constraint_factory_.basic().height.SetMin(kHeight);
306 auto result = SelectSettings();
307 EXPECT_TRUE(result.HasValue());
308 // kHeight is greater that the default, so expect kHeight.
309 EXPECT_EQ(kHeight, result.Height());
310 EXPECT_EQ(std::round(kHeight * kDefaultScreenCastAspectRatio),
311 result.Width());
312 CheckNonResolutionDefaults(result);
313 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
314 result.track_adapter_settings().min_aspect_ratio());
315 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kHeight,
316 result.track_adapter_settings().max_aspect_ratio());
317 CheckTrackAdapterSettingsEqualsFormat(result);
318
319 const int kSmallHeight = 100;
320 constraint_factory_.basic().height.SetMin(kSmallHeight);
321 result = SelectSettings();
322 EXPECT_TRUE(result.HasValue());
323 // kSmallHeight is less that the default, so expect the default.
324 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
325 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
326 CheckNonResolutionDefaults(result);
327 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
328 result.track_adapter_settings().min_aspect_ratio());
329 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kSmallHeight,
330 result.track_adapter_settings().max_aspect_ratio());
331 CheckTrackAdapterSettingsEqualsFormat(result);
332 }
333
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMaxHeight)334 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxHeight) {
335 // kMaxHeight smaller than the default.
336 {
337 constraint_factory_.Reset();
338 const int kMaxHeight = kDefaultScreenCastHeight - 100;
339 constraint_factory_.basic().height.SetMax(kMaxHeight);
340 auto result = SelectSettings();
341 EXPECT_TRUE(result.HasValue());
342 EXPECT_EQ(kMaxHeight, result.Height());
343 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
344 result.Width());
345 CheckNonResolutionDefaults(result);
346 EXPECT_EQ(1.0 / kMaxHeight,
347 result.track_adapter_settings().min_aspect_ratio());
348 EXPECT_EQ(kMaxScreenCastDimension,
349 result.track_adapter_settings().max_aspect_ratio());
350 CheckTrackAdapterSettingsEqualsFormat(result);
351 }
352
353 // kMaxHeight greater than the default.
354 {
355 constraint_factory_.Reset();
356 const int kMaxHeight = kDefaultScreenCastHeight + 100;
357 constraint_factory_.basic().height.SetMax(kMaxHeight);
358 auto result = SelectSettings();
359 EXPECT_TRUE(result.HasValue());
360 EXPECT_EQ(kMaxHeight, result.Height());
361 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
362 result.Width());
363 CheckNonResolutionDefaults(result);
364 EXPECT_EQ(1.0 / kMaxHeight,
365 result.track_adapter_settings().min_aspect_ratio());
366 EXPECT_EQ(kMaxScreenCastDimension,
367 result.track_adapter_settings().max_aspect_ratio());
368 CheckTrackAdapterSettingsEqualsFormat(result);
369 }
370
371 // kMaxHeight greater than the maximum allowed.
372 {
373 constraint_factory_.Reset();
374 constraint_factory_.basic().height.SetMax(kMaxScreenCastDimension + 1);
375 auto result = SelectSettings();
376 EXPECT_TRUE(result.HasValue());
377 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
378 EXPECT_EQ(
379 std::round(kDefaultScreenCastHeight * kDefaultScreenCastAspectRatio),
380 result.Width());
381 CheckNonResolutionDefaults(result);
382 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
383 result.track_adapter_settings().min_aspect_ratio());
384 EXPECT_EQ(kMaxScreenCastDimension,
385 result.track_adapter_settings().max_aspect_ratio());
386 CheckTrackAdapterSettingsEqualsFormat(result);
387 }
388
389 // kMaxHeight equal to the maximum allowed.
390 {
391 constraint_factory_.Reset();
392 const int kMaxHeight = kMaxScreenCastDimension;
393 constraint_factory_.basic().height.SetMax(kMaxHeight);
394 auto result = SelectSettings();
395 EXPECT_TRUE(result.HasValue());
396 EXPECT_EQ(kMaxHeight, result.Height());
397 // Since the given max is too large, the default aspect ratio cannot be
398 // used and the width is clamped to the maximum.
399 EXPECT_EQ(kMaxScreenCastDimension, result.Width());
400 CheckNonResolutionDefaults(result);
401 EXPECT_EQ(1.0 / kMaxHeight,
402 result.track_adapter_settings().min_aspect_ratio());
403 EXPECT_EQ(kMaxScreenCastDimension,
404 result.track_adapter_settings().max_aspect_ratio());
405 CheckTrackAdapterSettingsEqualsFormat(result);
406 }
407 }
408
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryHeightRange)409 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryHeightRange) {
410 // Range includes the default.
411 {
412 constraint_factory_.Reset();
413 const int kMinHeight = kDefaultScreenCastHeight - 100;
414 const int kMaxHeight = kDefaultScreenCastHeight + 100;
415 constraint_factory_.basic().height.SetMin(kMinHeight);
416 constraint_factory_.basic().height.SetMax(kMaxHeight);
417 auto result = SelectSettings();
418 EXPECT_TRUE(result.HasValue());
419 EXPECT_EQ(kMaxHeight, result.Height());
420 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
421 result.Width());
422 CheckNonResolutionDefaults(result);
423 EXPECT_EQ(1.0 / kMaxHeight,
424 result.track_adapter_settings().min_aspect_ratio());
425 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
426 result.track_adapter_settings().max_aspect_ratio());
427 CheckTrackAdapterSettingsEqualsFormat(result);
428 }
429
430 // The whole range is greater than the default.
431 {
432 constraint_factory_.Reset();
433 const int kMinHeight = kDefaultScreenCastHeight + 100;
434 const int kMaxHeight = kDefaultScreenCastHeight + 200;
435 constraint_factory_.basic().height.SetMin(kMinHeight);
436 constraint_factory_.basic().height.SetMax(kMaxHeight);
437 auto result = SelectSettings();
438 EXPECT_TRUE(result.HasValue());
439 EXPECT_EQ(kMaxHeight, result.Height());
440 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
441 result.Width());
442 CheckNonResolutionDefaults(result);
443 EXPECT_EQ(1.0 / kMaxHeight,
444 result.track_adapter_settings().min_aspect_ratio());
445 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
446 result.track_adapter_settings().max_aspect_ratio());
447 CheckTrackAdapterSettingsEqualsFormat(result);
448 }
449
450 // The whole range is less than the default.
451 {
452 constraint_factory_.Reset();
453 const int kMinHeight = kDefaultScreenCastHeight - 200;
454 const int kMaxHeight = kDefaultScreenCastHeight - 100;
455 constraint_factory_.basic().height.SetMin(kMinHeight);
456 constraint_factory_.basic().height.SetMax(kMaxHeight);
457 auto result = SelectSettings();
458 EXPECT_TRUE(result.HasValue());
459 EXPECT_EQ(kMaxHeight, result.Height());
460 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
461 result.Width());
462 CheckNonResolutionDefaults(result);
463 EXPECT_EQ(1.0 / kMaxHeight,
464 result.track_adapter_settings().min_aspect_ratio());
465 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
466 result.track_adapter_settings().max_aspect_ratio());
467 CheckTrackAdapterSettingsEqualsFormat(result);
468 }
469 }
470
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealHeight)471 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealHeight) {
472 // Unconstrained.
473 {
474 constraint_factory_.Reset();
475 const int kIdealHeight = 1000;
476 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
477 auto result = SelectSettings();
478 EXPECT_TRUE(result.HasValue());
479 EXPECT_EQ(kIdealHeight, result.Height());
480 // When ideal height is given, the algorithm returns a width that is closest
481 // to height * kDefaultScreenCastAspectRatio.
482 EXPECT_EQ(std::round(kIdealHeight * kDefaultScreenCastAspectRatio),
483 result.Width());
484 CheckNonResolutionDefaults(result);
485 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
486 }
487
488 // Ideal greater than maximum.
489 {
490 constraint_factory_.Reset();
491 const int kIdealHeight = 1000;
492 const int kMaxHeight = 800;
493 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
494 constraint_factory_.basic().height.SetMax(kMaxHeight);
495 auto result = SelectSettings();
496 EXPECT_TRUE(result.HasValue());
497 // Ideal height is greater than the maximum, expect maximum.
498 EXPECT_EQ(kMaxHeight, result.Height());
499 // Expect closest to kMaxHeight * kDefaultScreenCastAspectRatio.
500 EXPECT_EQ(std::round(kMaxHeight * kDefaultScreenCastAspectRatio),
501 result.Width());
502 CheckNonResolutionDefaults(result);
503 EXPECT_EQ(1.0 / kMaxHeight,
504 result.track_adapter_settings().min_aspect_ratio());
505 EXPECT_EQ(kMaxScreenCastDimension,
506 result.track_adapter_settings().max_aspect_ratio());
507 CheckTrackAdapterSettingsEqualsFormat(result);
508 }
509
510 // Ideal less than minimum.
511 {
512 constraint_factory_.Reset();
513 const int kIdealHeight = 1000;
514 const int kMinHeight = 1200;
515 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
516 constraint_factory_.basic().height.SetMin(kMinHeight);
517 auto result = SelectSettings();
518 EXPECT_TRUE(result.HasValue());
519 // Ideal height is less than the minimum, expect minimum.
520 EXPECT_EQ(kMinHeight, result.Height());
521 // Expect closest to kMinHeight * kDefaultScreenCastAspectRatio.
522 EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio),
523 result.Width());
524 CheckNonResolutionDefaults(result);
525 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
526 result.track_adapter_settings().min_aspect_ratio());
527 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
528 result.track_adapter_settings().max_aspect_ratio());
529 CheckTrackAdapterSettingsEqualsFormat(result);
530 }
531
532 // Ideal intersects a box.
533 {
534 constraint_factory_.Reset();
535 constraint_factory_.basic().height.SetMin(500);
536 constraint_factory_.basic().height.SetMax(1000);
537 constraint_factory_.basic().width.SetMin(100);
538 constraint_factory_.basic().width.SetMax(500);
539 const int kIdealHeight = 750;
540 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
541 auto result = SelectSettings();
542 EXPECT_TRUE(result.HasValue());
543 // Ideal height is included in the bounding box.
544 EXPECT_EQ(kIdealHeight, result.Height());
545 double default_aspect_ratio =
546 static_cast<double>(constraint_factory_.basic().width.Max()) /
547 constraint_factory_.basic().height.Max();
548 // Expect width closest to kIdealHeight * default aspect ratio.
549 EXPECT_EQ(std::round(kIdealHeight * default_aspect_ratio), result.Width());
550 CheckNonResolutionDefaults(result);
551 EXPECT_EQ(100.0 / 1000.0,
552 result.track_adapter_settings().min_aspect_ratio());
553 EXPECT_EQ(500.0 / 500.0,
554 result.track_adapter_settings().max_aspect_ratio());
555 CheckTrackAdapterSettingsEqualsFormat(result);
556 }
557
558 // Ideal outside the box, closest to the side coinciding with max height.
559 {
560 const int kMaxHeight = 1000;
561 constraint_factory_.Reset();
562 constraint_factory_.basic().height.SetMin(500);
563 constraint_factory_.basic().height.SetMax(kMaxHeight);
564 constraint_factory_.basic().width.SetMin(100);
565 constraint_factory_.basic().width.SetMax(500);
566 constraint_factory_.basic().height.SetIdeal(1200);
567 auto result = SelectSettings();
568 EXPECT_TRUE(result.HasValue());
569 EXPECT_EQ(kMaxHeight, result.Height());
570 // Expect width closest to kMaxHeight * default aspect ratio, which is
571 // outside the box. Closest it max width.
572 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
573 CheckNonResolutionDefaults(result);
574 EXPECT_EQ(100.0 / kMaxHeight,
575 result.track_adapter_settings().min_aspect_ratio());
576 EXPECT_EQ(500.0 / 500.0,
577 result.track_adapter_settings().max_aspect_ratio());
578 CheckTrackAdapterSettingsEqualsFormat(result);
579 }
580
581 // Ideal outside the constrained set, closest to a single point.
582 {
583 constraint_factory_.Reset();
584 constraint_factory_.basic().height.SetMin(500);
585 constraint_factory_.basic().height.SetMax(1000);
586 constraint_factory_.basic().width.SetMin(500);
587 constraint_factory_.basic().width.SetMax(1000);
588 constraint_factory_.basic().aspect_ratio.SetMin(1.0);
589 constraint_factory_.basic().height.SetIdeal(1200);
590 auto result = SelectSettings();
591 EXPECT_TRUE(result.HasValue());
592 // (max-height, max-width) is the single point closest to the ideal line.
593 EXPECT_EQ(constraint_factory_.basic().height.Max(), result.Height());
594 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
595 CheckNonResolutionDefaults(result);
596 EXPECT_EQ(1.0, result.track_adapter_settings().min_aspect_ratio());
597 EXPECT_EQ(1000.0 / 500.0,
598 result.track_adapter_settings().max_aspect_ratio());
599 CheckTrackAdapterSettingsEqualsFormat(result);
600 }
601 }
602
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryExactWidth)603 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactWidth) {
604 constraint_factory_.Reset();
605 const int kWidth = 1000;
606 constraint_factory_.basic().width.SetExact(kWidth);
607 auto result = SelectSettings();
608 EXPECT_TRUE(result.HasValue());
609 EXPECT_EQ(kWidth, result.Width());
610 EXPECT_EQ(std::round(kWidth / kDefaultScreenCastAspectRatio),
611 result.Height());
612 CheckNonResolutionDefaults(result);
613 EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension,
614 result.track_adapter_settings().min_aspect_ratio());
615 EXPECT_EQ(static_cast<double>(kWidth) / kMinScreenCastDimension,
616 result.track_adapter_settings().max_aspect_ratio());
617 CheckTrackAdapterSettingsEqualsFormat(result);
618 }
619
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMinWidth)620 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinWidth) {
621 constraint_factory_.Reset();
622 const int kWidth = 3000;
623 constraint_factory_.basic().width.SetMin(kWidth);
624 auto result = SelectSettings();
625 EXPECT_TRUE(result.HasValue());
626 // kWidth is greater that the default, so expect kWidth.
627 EXPECT_EQ(kWidth, result.Width());
628 EXPECT_EQ(std::round(kWidth / kDefaultScreenCastAspectRatio),
629 result.Height());
630 CheckNonResolutionDefaults(result);
631 EXPECT_EQ(static_cast<double>(kWidth) / kMaxScreenCastDimension,
632 result.track_adapter_settings().min_aspect_ratio());
633 EXPECT_EQ(
634 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
635 result.track_adapter_settings().max_aspect_ratio());
636 CheckTrackAdapterSettingsEqualsFormat(result);
637
638 const int kSmallWidth = 100;
639 constraint_factory_.basic().width.SetMin(kSmallWidth);
640 result = SelectSettings();
641 EXPECT_TRUE(result.HasValue());
642 // kSmallWidth is less that the default, so expect the default.
643 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
644 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
645 CheckNonResolutionDefaults(result);
646 EXPECT_EQ(static_cast<double>(kSmallWidth) / kMaxScreenCastDimension,
647 result.track_adapter_settings().min_aspect_ratio());
648 EXPECT_EQ(
649 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
650 result.track_adapter_settings().max_aspect_ratio());
651 CheckTrackAdapterSettingsEqualsFormat(result);
652 }
653
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMaxWidth)654 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxWidth) {
655 // kMaxWidth less than the default.
656 {
657 constraint_factory_.Reset();
658 const int kMaxWidth = kDefaultScreenCastWidth - 100;
659 constraint_factory_.basic().width.SetMax(kMaxWidth);
660 auto result = SelectSettings();
661 EXPECT_TRUE(result.HasValue());
662 // If max is provided, max is used as default.
663 EXPECT_EQ(kMaxWidth, result.Width());
664 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
665 result.Height());
666 CheckNonResolutionDefaults(result);
667 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
668 result.track_adapter_settings().min_aspect_ratio());
669 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
670 result.track_adapter_settings().max_aspect_ratio());
671 CheckTrackAdapterSettingsEqualsFormat(result);
672 }
673
674 // kMaxWidth greater than the default.
675 {
676 constraint_factory_.Reset();
677 const int kMaxWidth = kDefaultScreenCastWidth + 100;
678 constraint_factory_.basic().width.SetMax(kMaxWidth);
679 auto result = SelectSettings();
680 EXPECT_TRUE(result.HasValue());
681 // If max is provided, max is used as default.
682 EXPECT_EQ(kMaxWidth, result.Width());
683 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
684 result.Height());
685 CheckNonResolutionDefaults(result);
686 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
687 result.track_adapter_settings().min_aspect_ratio());
688 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
689 result.track_adapter_settings().max_aspect_ratio());
690 CheckTrackAdapterSettingsEqualsFormat(result);
691 }
692
693 // kMaxWidth greater than the maximum allowed (gets ignored).
694 {
695 constraint_factory_.Reset();
696 constraint_factory_.basic().width.SetMax(kMaxScreenCastDimension + 1);
697 auto result = SelectSettings();
698 EXPECT_TRUE(result.HasValue());
699 // Expect the default, since the given max value cannot be used as default.
700 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
701 EXPECT_EQ(
702 std::round(kDefaultScreenCastWidth / kDefaultScreenCastAspectRatio),
703 result.Height());
704 CheckNonResolutionDefaults(result);
705 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
706 result.track_adapter_settings().min_aspect_ratio());
707 EXPECT_EQ(
708 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
709 result.track_adapter_settings().max_aspect_ratio());
710 CheckTrackAdapterSettingsEqualsFormat(result);
711 }
712
713 // kMaxWidth equal to the maximum allowed.
714 {
715 constraint_factory_.Reset();
716 const int kMaxWidth = kMaxScreenCastDimension;
717 constraint_factory_.basic().width.SetMax(kMaxWidth);
718 auto result = SelectSettings();
719 EXPECT_TRUE(result.HasValue());
720 EXPECT_EQ(kMaxWidth, result.Width());
721 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
722 result.Height());
723 CheckNonResolutionDefaults(result);
724 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
725 result.track_adapter_settings().min_aspect_ratio());
726 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
727 result.track_adapter_settings().max_aspect_ratio());
728 CheckTrackAdapterSettingsEqualsFormat(result);
729 }
730 }
731
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryWidthRange)732 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryWidthRange) {
733 // The whole range is less than the default.
734 {
735 constraint_factory_.Reset();
736 const int kMinWidth = kDefaultScreenCastWidth - 200;
737 const int kMaxWidth = kDefaultScreenCastWidth - 100;
738 constraint_factory_.basic().width.SetMin(kMinWidth);
739 constraint_factory_.basic().width.SetMax(kMaxWidth);
740 auto result = SelectSettings();
741 EXPECT_TRUE(result.HasValue());
742 EXPECT_EQ(kMaxWidth, result.Width());
743 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
744 result.Height());
745 CheckNonResolutionDefaults(result);
746 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
747 result.track_adapter_settings().min_aspect_ratio());
748 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
749 result.track_adapter_settings().max_aspect_ratio());
750 CheckTrackAdapterSettingsEqualsFormat(result);
751 }
752
753 // The range includes the default.
754 {
755 constraint_factory_.Reset();
756 const int kMinWidth = kDefaultScreenCastWidth - 100;
757 const int kMaxWidth = kDefaultScreenCastWidth + 100;
758 constraint_factory_.basic().width.SetMin(kMinWidth);
759 constraint_factory_.basic().width.SetMax(kMaxWidth);
760 auto result = SelectSettings();
761 EXPECT_TRUE(result.HasValue());
762 EXPECT_EQ(kMaxWidth, result.Width());
763 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
764 result.Height());
765 CheckNonResolutionDefaults(result);
766 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
767 result.track_adapter_settings().min_aspect_ratio());
768 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
769 result.track_adapter_settings().max_aspect_ratio());
770 CheckTrackAdapterSettingsEqualsFormat(result);
771 }
772
773 // The whole range is greater than the default.
774 {
775 constraint_factory_.Reset();
776 const int kMinWidth = kDefaultScreenCastWidth + 100;
777 const int kMaxWidth = kDefaultScreenCastWidth + 200;
778 constraint_factory_.basic().width.SetMin(kMinWidth);
779 constraint_factory_.basic().width.SetMax(kMaxWidth);
780 auto result = SelectSettings();
781 EXPECT_TRUE(result.HasValue());
782 EXPECT_EQ(kMaxWidth, result.Width());
783 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
784 result.Height());
785 CheckNonResolutionDefaults(result);
786 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
787 result.track_adapter_settings().min_aspect_ratio());
788 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
789 result.track_adapter_settings().max_aspect_ratio());
790 CheckTrackAdapterSettingsEqualsFormat(result);
791 }
792 }
793
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealWidth)794 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealWidth) {
795 // Unconstrained
796 {
797 constraint_factory_.Reset();
798 const int kIdealWidth = 1000;
799 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
800 auto result = SelectSettings();
801 EXPECT_TRUE(result.HasValue());
802 EXPECT_EQ(kIdealWidth, result.Width());
803 // When ideal width is given, the algorithm returns a height that is closest
804 // to width / kDefaultScreenCastAspectRatio.
805 EXPECT_EQ(std::round(kIdealWidth / kDefaultScreenCastAspectRatio),
806 result.Height());
807 CheckNonResolutionDefaults(result);
808 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
809 }
810
811 // Ideal greater than maximum.
812 {
813 constraint_factory_.Reset();
814 const int kIdealWidth = 1000;
815 const int kMaxWidth = 800;
816 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
817 constraint_factory_.basic().width.SetMax(kMaxWidth);
818 auto result = SelectSettings();
819 EXPECT_TRUE(result.HasValue());
820 EXPECT_EQ(kMaxWidth, result.Width());
821 // Expect closest to kMaxWidth / kDefaultScreenCastAspectRatio.
822 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
823 result.Height());
824 CheckNonResolutionDefaults(result);
825 EXPECT_EQ(1.0 / kMaxScreenCastDimension,
826 result.track_adapter_settings().min_aspect_ratio());
827 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
828 result.track_adapter_settings().max_aspect_ratio());
829 CheckTrackAdapterSettingsEqualsFormat(result);
830 }
831
832 // Ideal less than minimum.
833 {
834 constraint_factory_.Reset();
835 const int kIdealWidth = 1000;
836 const int kMinWidth = 1200;
837 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
838 constraint_factory_.basic().width.SetMin(kMinWidth);
839 auto result = SelectSettings();
840 EXPECT_TRUE(result.HasValue());
841 EXPECT_EQ(kMinWidth, result.Width());
842 // Expect closest to kMinWidth / kDefaultScreenCastAspectRatio.
843 EXPECT_EQ(std::round(kMinWidth / kDefaultScreenCastAspectRatio),
844 result.Height());
845 CheckNonResolutionDefaults(result);
846 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
847 result.track_adapter_settings().min_aspect_ratio());
848 EXPECT_EQ(
849 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
850 result.track_adapter_settings().max_aspect_ratio());
851 CheckTrackAdapterSettingsEqualsFormat(result);
852 }
853
854 // Ideal intersects a box.
855 {
856 constraint_factory_.Reset();
857 constraint_factory_.basic().width.SetMin(500);
858 constraint_factory_.basic().width.SetMax(1000);
859 constraint_factory_.basic().height.SetMin(100);
860 constraint_factory_.basic().height.SetMax(500);
861 const int kIdealWidth = 750;
862 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
863 auto result = SelectSettings();
864 EXPECT_TRUE(result.HasValue());
865 // Ideal width is included in the bounding box.
866 EXPECT_EQ(kIdealWidth, result.Width());
867 // Expect height closest to kIdealWidth / default aspect ratio.
868 double default_aspect_ratio =
869 static_cast<double>(constraint_factory_.basic().width.Max()) /
870 constraint_factory_.basic().height.Max();
871 EXPECT_EQ(std::round(kIdealWidth / default_aspect_ratio), result.Height());
872 CheckNonResolutionDefaults(result);
873 EXPECT_EQ(500.0 / 500.0,
874 result.track_adapter_settings().min_aspect_ratio());
875 EXPECT_EQ(1000.0 / 100.0,
876 result.track_adapter_settings().max_aspect_ratio());
877 CheckTrackAdapterSettingsEqualsFormat(result);
878 }
879
880 // Ideal outside the box, closest to the side coinciding with max width.
881 {
882 const int kMaxWidth = 1000;
883 constraint_factory_.Reset();
884 constraint_factory_.basic().width.SetMin(500);
885 constraint_factory_.basic().width.SetMax(kMaxWidth);
886 constraint_factory_.basic().height.SetMin(100);
887 constraint_factory_.basic().height.SetMax(500);
888 constraint_factory_.basic().width.SetIdeal(1200);
889 auto result = SelectSettings();
890 EXPECT_TRUE(result.HasValue());
891 EXPECT_EQ(kMaxWidth, result.Width());
892 // kMaxWidth / kDefaultScreenCastAspectRatio is outside the box. Closest is
893 // max height.
894 EXPECT_EQ(constraint_factory_.basic().height.Max(), result.Height());
895 CheckNonResolutionDefaults(result);
896 EXPECT_EQ(500.0 / 500.0,
897 result.track_adapter_settings().min_aspect_ratio());
898 EXPECT_EQ(static_cast<double>(kMaxWidth) / 100.0,
899 result.track_adapter_settings().max_aspect_ratio());
900 CheckTrackAdapterSettingsEqualsFormat(result);
901 }
902
903 // Ideal outside the constrained set, closest to a single point.
904 {
905 constraint_factory_.Reset();
906 constraint_factory_.basic().width.SetMin(100);
907 constraint_factory_.basic().width.SetMax(500);
908 constraint_factory_.basic().height.SetMin(100);
909 constraint_factory_.basic().height.SetMax(500);
910 constraint_factory_.basic().aspect_ratio.SetMax(1.0);
911 constraint_factory_.basic().width.SetIdeal(1200);
912 auto result = SelectSettings();
913 EXPECT_TRUE(result.HasValue());
914 // (max-width, max-height) is the single point closest to the ideal line.
915 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
916 EXPECT_EQ(constraint_factory_.basic().height.Max(), result.Height());
917 CheckNonResolutionDefaults(result);
918 EXPECT_EQ(100.0 / 500.0,
919 result.track_adapter_settings().min_aspect_ratio());
920 EXPECT_EQ(1.0, result.track_adapter_settings().max_aspect_ratio());
921 CheckTrackAdapterSettingsEqualsFormat(result);
922 }
923 }
924
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryExactAspectRatio)925 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactAspectRatio) {
926 constraint_factory_.Reset();
927 const double kAspectRatio = 2.0;
928 constraint_factory_.basic().aspect_ratio.SetExact(kAspectRatio);
929 auto result = SelectSettings();
930 EXPECT_TRUE(result.HasValue());
931 // Given that the default aspect ratio cannot be preserved, the algorithm
932 // tries to preserve, among the default height or width, the one that leads
933 // to highest area. In this case, height is preserved.
934 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
935 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kAspectRatio),
936 result.Width());
937 CheckNonResolutionDefaults(result);
938 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().min_aspect_ratio());
939 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().max_aspect_ratio());
940 CheckTrackAdapterSettingsEqualsFormat(result);
941 }
942
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMinAspectRatio)943 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinAspectRatio) {
944 constraint_factory_.Reset();
945 const double kAspectRatio = 2.0;
946 constraint_factory_.basic().aspect_ratio.SetMin(kAspectRatio);
947 auto result = SelectSettings();
948 EXPECT_TRUE(result.HasValue());
949 // kAspectRatio is greater that the default, so expect kAspectRatio.
950 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
951 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kAspectRatio),
952 result.Width());
953 CheckNonResolutionDefaults(result);
954 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().min_aspect_ratio());
955 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) /
956 static_cast<double>(kMinScreenCastDimension),
957 result.track_adapter_settings().max_aspect_ratio());
958 CheckTrackAdapterSettingsEqualsFormat(result);
959
960 const double kSmallAspectRatio = 0.5;
961 constraint_factory_.basic().aspect_ratio.SetMin(kSmallAspectRatio);
962 result = SelectSettings();
963 EXPECT_TRUE(result.HasValue());
964 // kSmallAspectRatio is less that the default, so expect the default.
965 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
966 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
967 CheckNonResolutionDefaults(result);
968 EXPECT_EQ(kSmallAspectRatio,
969 result.track_adapter_settings().min_aspect_ratio());
970 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) /
971 static_cast<double>(kMinScreenCastDimension),
972 result.track_adapter_settings().max_aspect_ratio());
973 CheckTrackAdapterSettingsEqualsFormat(result);
974 }
975
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMaxAspectRatio)976 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxAspectRatio) {
977 constraint_factory_.Reset();
978 const double kAspectRatio = 2.0;
979 constraint_factory_.basic().aspect_ratio.SetMax(kAspectRatio);
980 auto result = SelectSettings();
981 EXPECT_TRUE(result.HasValue());
982 // kAspectRatio is greater that the default, so expect the default.
983 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
984 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
985 CheckNonResolutionDefaults(result);
986 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) /
987 static_cast<double>(kMaxScreenCastDimension),
988 result.track_adapter_settings().min_aspect_ratio());
989 EXPECT_EQ(kAspectRatio, result.track_adapter_settings().max_aspect_ratio());
990 CheckTrackAdapterSettingsEqualsFormat(result);
991
992 const double kSmallAspectRatio = 0.5;
993 constraint_factory_.basic().aspect_ratio.SetMax(kSmallAspectRatio);
994 result = SelectSettings();
995 EXPECT_TRUE(result.HasValue());
996 // kSmallAspectRatio is less that the default, so expect kSmallAspectRatio.
997 // Prefer to preserve default width since that leads to larger area than
998 // preserving default height.
999 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kSmallAspectRatio),
1000 result.Height());
1001 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1002 CheckNonResolutionDefaults(result);
1003 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) /
1004 static_cast<double>(kMaxScreenCastDimension),
1005 result.track_adapter_settings().min_aspect_ratio());
1006 EXPECT_EQ(kSmallAspectRatio,
1007 result.track_adapter_settings().max_aspect_ratio());
1008 CheckTrackAdapterSettingsEqualsFormat(result);
1009 }
1010
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryRangeAspectRatio)1011 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeAspectRatio) {
1012 constraint_factory_.Reset();
1013 {
1014 const double kMinAspectRatio = 0.5;
1015 const double kMaxAspectRatio = 2.0;
1016 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1017 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1018 auto result = SelectSettings();
1019 EXPECT_TRUE(result.HasValue());
1020 // Range includes default, so expect the default.
1021 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1022 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1023 CheckNonResolutionDefaults(result);
1024 EXPECT_EQ(kMinAspectRatio,
1025 result.track_adapter_settings().min_aspect_ratio());
1026 EXPECT_EQ(kMaxAspectRatio,
1027 result.track_adapter_settings().max_aspect_ratio());
1028 CheckTrackAdapterSettingsEqualsFormat(result);
1029 }
1030
1031 {
1032 const double kMinAspectRatio = 2.0;
1033 const double kMaxAspectRatio = 3.0;
1034 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1035 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1036 auto result = SelectSettings();
1037 EXPECT_TRUE(result.HasValue());
1038 // The whole range is greater than the default. Expect the minimum.
1039 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1040 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio),
1041 result.Width());
1042 CheckNonResolutionDefaults(result);
1043 EXPECT_EQ(kMinAspectRatio,
1044 result.track_adapter_settings().min_aspect_ratio());
1045 EXPECT_EQ(kMaxAspectRatio,
1046 result.track_adapter_settings().max_aspect_ratio());
1047 CheckTrackAdapterSettingsEqualsFormat(result);
1048 }
1049
1050 {
1051 const double kMinAspectRatio = 0.5;
1052 const double kMaxAspectRatio = 1.0;
1053 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1054 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1055 auto result = SelectSettings();
1056 EXPECT_TRUE(result.HasValue());
1057 // The whole range is less than the default. Expect the maximum.
1058 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMaxAspectRatio),
1059 result.Height());
1060 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1061 CheckNonResolutionDefaults(result);
1062 EXPECT_EQ(kMinAspectRatio,
1063 result.track_adapter_settings().min_aspect_ratio());
1064 EXPECT_EQ(kMaxAspectRatio,
1065 result.track_adapter_settings().max_aspect_ratio());
1066 CheckTrackAdapterSettingsEqualsFormat(result);
1067 }
1068 }
1069
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealAspectRatio)1070 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealAspectRatio) {
1071 // Unconstrained.
1072 {
1073 constraint_factory_.Reset();
1074 const double kIdealAspectRatio = 2.0;
1075 constraint_factory_.basic().aspect_ratio.SetIdeal(kIdealAspectRatio);
1076 auto result = SelectSettings();
1077 EXPECT_TRUE(result.HasValue());
1078 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1079 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kIdealAspectRatio),
1080 result.Width());
1081 CheckNonResolutionDefaults(result);
1082 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1083 }
1084
1085 // Ideal greater than maximum.
1086 {
1087 constraint_factory_.Reset();
1088 const double kIdealAspectRatio = 2.0;
1089 const double kMaxAspectRatio = 1.5;
1090 constraint_factory_.basic().aspect_ratio.SetIdeal(kIdealAspectRatio);
1091 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1092 auto result = SelectSettings();
1093 EXPECT_TRUE(result.HasValue());
1094 // Ideal aspect ratio is greater than the maximum, expect maximum.
1095 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMaxAspectRatio),
1096 result.Height());
1097 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1098 CheckNonResolutionDefaults(result);
1099 EXPECT_EQ(
1100 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension,
1101 result.track_adapter_settings().min_aspect_ratio());
1102 EXPECT_EQ(kMaxAspectRatio,
1103 result.track_adapter_settings().max_aspect_ratio());
1104 CheckTrackAdapterSettingsEqualsFormat(result);
1105 }
1106
1107 // Ideal less than minimum.
1108 {
1109 constraint_factory_.Reset();
1110 const double kIdealAspectRatio = 1.0;
1111 const double kMinAspectRatio = 1.5;
1112 constraint_factory_.basic().aspect_ratio.SetIdeal(kIdealAspectRatio);
1113 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1114 auto result = SelectSettings();
1115 EXPECT_TRUE(result.HasValue());
1116 // Ideal aspect ratio is less than the maximum, expect minimum.
1117 EXPECT_EQ(std::round(kDefaultScreenCastWidth / kMinAspectRatio),
1118 result.Height());
1119 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1120 CheckNonResolutionDefaults(result);
1121 EXPECT_EQ(kMinAspectRatio,
1122 result.track_adapter_settings().min_aspect_ratio());
1123 EXPECT_EQ(
1124 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
1125 result.track_adapter_settings().max_aspect_ratio());
1126 CheckTrackAdapterSettingsEqualsFormat(result);
1127 }
1128
1129 // Ideal intersects a box.
1130 {
1131 constraint_factory_.Reset();
1132 constraint_factory_.basic().height.SetMin(100);
1133 constraint_factory_.basic().height.SetMax(500);
1134 constraint_factory_.basic().width.SetMin(100);
1135 constraint_factory_.basic().width.SetMax(500);
1136 const double kIdealAspectRatio = 2.0;
1137 constraint_factory_.basic().aspect_ratio.SetIdeal(kIdealAspectRatio);
1138 auto result = SelectSettings();
1139 EXPECT_TRUE(result.HasValue());
1140 // Ideal aspect-ratio is included in the bounding box, with the value
1141 // closest to a standard width or height being the cut with the maximum
1142 // width.
1143 EXPECT_EQ(
1144 std::round(constraint_factory_.basic().width.Max() / kIdealAspectRatio),
1145 result.Height());
1146 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
1147 CheckNonResolutionDefaults(result);
1148 EXPECT_EQ(100.0 / 500.0,
1149 result.track_adapter_settings().min_aspect_ratio());
1150 EXPECT_EQ(500.0 / 100.0,
1151 result.track_adapter_settings().max_aspect_ratio());
1152 CheckTrackAdapterSettingsEqualsFormat(result);
1153
1154 constraint_factory_.basic().height.SetMin(1000);
1155 constraint_factory_.basic().height.SetMax(5000);
1156 constraint_factory_.basic().width.SetMin(1000);
1157 constraint_factory_.basic().width.SetMax(5000);
1158 result = SelectSettings();
1159 EXPECT_TRUE(result.HasValue());
1160 // Ideal aspect-ratio is included in the bounding box.
1161 EXPECT_EQ(
1162 std::round(constraint_factory_.basic().width.Max() / kIdealAspectRatio),
1163 result.Height());
1164 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
1165 CheckNonResolutionDefaults(result);
1166 EXPECT_EQ(1000.0 / 5000.0,
1167 result.track_adapter_settings().min_aspect_ratio());
1168 EXPECT_EQ(5000.0 / 1000.0,
1169 result.track_adapter_settings().max_aspect_ratio());
1170 CheckTrackAdapterSettingsEqualsFormat(result);
1171
1172 constraint_factory_.Reset();
1173 constraint_factory_.basic().aspect_ratio.SetIdeal(kIdealAspectRatio);
1174 constraint_factory_.basic().height.SetMin(250);
1175 constraint_factory_.basic().width.SetMin(250);
1176 result = SelectSettings();
1177 EXPECT_TRUE(result.HasValue());
1178 // Ideal aspect-ratio is included in the bounding box. Preserving default
1179 // height leads to larger area than preserving default width.
1180 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1181 EXPECT_EQ(kDefaultScreenCastHeight * kIdealAspectRatio, result.Width());
1182 CheckNonResolutionDefaults(result);
1183 EXPECT_EQ(250.0 / kMaxScreenCastDimension,
1184 result.track_adapter_settings().min_aspect_ratio());
1185 EXPECT_EQ(kMaxScreenCastDimension / 250.0,
1186 result.track_adapter_settings().max_aspect_ratio());
1187 CheckTrackAdapterSettingsEqualsFormat(result);
1188 }
1189
1190 // Ideal outside the constrained area, closest to min or max aspect ratio.
1191 {
1192 const double kMinAspectRatio = 0.5;
1193 const double kMaxAspectRatio = 2.0;
1194 constraint_factory_.Reset();
1195 constraint_factory_.basic().height.SetMin(100);
1196 constraint_factory_.basic().height.SetMax(500);
1197 constraint_factory_.basic().width.SetMin(100);
1198 constraint_factory_.basic().width.SetMax(500);
1199 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1200 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1201 constraint_factory_.basic().aspect_ratio.SetIdeal(3.0);
1202 auto result = SelectSettings();
1203 EXPECT_TRUE(result.HasValue());
1204 // Ideal is closest to kMaxAspectRatio.
1205 EXPECT_EQ(
1206 std::round(constraint_factory_.basic().width.Max() / kMaxAspectRatio),
1207 result.Height());
1208 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
1209 CheckNonResolutionDefaults(result);
1210 EXPECT_EQ(kMinAspectRatio,
1211 result.track_adapter_settings().min_aspect_ratio());
1212 EXPECT_EQ(kMaxAspectRatio,
1213 result.track_adapter_settings().max_aspect_ratio());
1214 CheckTrackAdapterSettingsEqualsFormat(result);
1215
1216 constraint_factory_.basic().aspect_ratio.SetIdeal(0.3);
1217 result = SelectSettings();
1218 EXPECT_TRUE(result.HasValue());
1219 // Ideal is closest to kMinAspectRatio.
1220 EXPECT_EQ(constraint_factory_.basic().height.Max(), result.Height());
1221 EXPECT_EQ(
1222 std::round(constraint_factory_.basic().height.Max() * kMinAspectRatio),
1223 result.Width());
1224 CheckNonResolutionDefaults(result);
1225 EXPECT_EQ(kMinAspectRatio,
1226 result.track_adapter_settings().min_aspect_ratio());
1227 EXPECT_EQ(kMaxAspectRatio,
1228 result.track_adapter_settings().max_aspect_ratio());
1229 CheckTrackAdapterSettingsEqualsFormat(result);
1230
1231 // Use a box that is bigger and further from the origin to force closeness
1232 // to a different default dimension.
1233 constraint_factory_.Reset();
1234 constraint_factory_.basic().aspect_ratio.SetMin(kMinAspectRatio);
1235 constraint_factory_.basic().aspect_ratio.SetMax(kMaxAspectRatio);
1236 constraint_factory_.basic().height.SetMin(3000);
1237 constraint_factory_.basic().width.SetMin(3000);
1238 constraint_factory_.basic().aspect_ratio.SetIdeal(3.0);
1239 result = SelectSettings();
1240 EXPECT_TRUE(result.HasValue());
1241 // Ideal is closest to kMaxAspectRatio.
1242 EXPECT_EQ(constraint_factory_.basic().height.Min(), result.Height());
1243 EXPECT_EQ(
1244 std::round(constraint_factory_.basic().height.Min() * kMaxAspectRatio),
1245 result.Width());
1246 CheckNonResolutionDefaults(result);
1247 EXPECT_EQ(kMinAspectRatio,
1248 result.track_adapter_settings().min_aspect_ratio());
1249 EXPECT_EQ(kMaxAspectRatio,
1250 result.track_adapter_settings().max_aspect_ratio());
1251 CheckTrackAdapterSettingsEqualsFormat(result);
1252
1253 constraint_factory_.basic().aspect_ratio.SetIdeal(0.3);
1254 result = SelectSettings();
1255 EXPECT_TRUE(result.HasValue());
1256 // Ideal is closest to kMinAspectRatio.
1257 EXPECT_EQ(
1258 std::round(constraint_factory_.basic().width.Min() / kMinAspectRatio),
1259 result.Height());
1260 EXPECT_EQ(constraint_factory_.basic().width.Min(), result.Width());
1261 CheckNonResolutionDefaults(result);
1262 EXPECT_EQ(kMinAspectRatio,
1263 result.track_adapter_settings().min_aspect_ratio());
1264 EXPECT_EQ(kMaxAspectRatio,
1265 result.track_adapter_settings().max_aspect_ratio());
1266 CheckTrackAdapterSettingsEqualsFormat(result);
1267 }
1268
1269 // Ideal outside the constrained area, closest to a single point.
1270 {
1271 constraint_factory_.Reset();
1272 constraint_factory_.basic().height.SetMin(100);
1273 constraint_factory_.basic().height.SetMax(500);
1274 constraint_factory_.basic().width.SetMin(100);
1275 constraint_factory_.basic().width.SetMax(500);
1276 constraint_factory_.basic().aspect_ratio.SetMin(1.0);
1277 constraint_factory_.basic().aspect_ratio.SetIdeal(10.0);
1278 auto result = SelectSettings();
1279 EXPECT_TRUE(result.HasValue());
1280 // Ideal is closest to the min height and max width.
1281 EXPECT_EQ(constraint_factory_.basic().height.Min(), result.Height());
1282 EXPECT_EQ(constraint_factory_.basic().width.Max(), result.Width());
1283 CheckNonResolutionDefaults(result);
1284 EXPECT_EQ(1.0, result.track_adapter_settings().min_aspect_ratio());
1285 EXPECT_EQ(500.0 / 100.0,
1286 result.track_adapter_settings().max_aspect_ratio());
1287 CheckTrackAdapterSettingsEqualsFormat(result);
1288 }
1289 }
1290
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryExactFrameRate)1291 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryExactFrameRate) {
1292 constraint_factory_.Reset();
1293 const double kFrameRate = 45.0;
1294 constraint_factory_.basic().frame_rate.SetExact(kFrameRate);
1295 auto result = SelectSettings();
1296 EXPECT_TRUE(result.HasValue());
1297 EXPECT_EQ(kFrameRate, result.FrameRate());
1298 EXPECT_EQ(kFrameRate, result.min_frame_rate());
1299 EXPECT_EQ(kFrameRate, result.max_frame_rate());
1300 CheckNonFrameRateDefaults(result);
1301 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result, kFrameRate);
1302 }
1303
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMinFrameRate)1304 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMinFrameRate) {
1305 // MinFrameRate greater than the default frame rate.
1306 {
1307 constraint_factory_.Reset();
1308 const double kMinFrameRate = 45.0;
1309 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1310 auto result = SelectSettings();
1311 EXPECT_TRUE(result.HasValue());
1312 // kMinFrameRate is greater that the default, so expect kMinFrameRate.
1313 EXPECT_EQ(kMinFrameRate, result.FrameRate());
1314 EXPECT_TRUE(result.min_frame_rate().has_value());
1315 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1316 EXPECT_FALSE(result.max_frame_rate().has_value());
1317 CheckNonFrameRateDefaults(result);
1318 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1319 }
1320
1321 // MinFrameRate less than the default frame rate.
1322 {
1323 const double kMinFrameRate = 5.0;
1324 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1325 auto result = SelectSettings();
1326 EXPECT_TRUE(result.HasValue());
1327 // No ideal or maximum frame rate given, expect default.
1328 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1329 EXPECT_TRUE(result.min_frame_rate().has_value());
1330 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1331 EXPECT_FALSE(result.max_frame_rate().has_value());
1332 CheckNonFrameRateDefaults(result);
1333 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1334 }
1335
1336 // MinFrameRate less than the minimum allowed.
1337 {
1338 const double kMinFrameRate = -0.01;
1339 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1340 auto result = SelectSettings();
1341 EXPECT_TRUE(result.HasValue());
1342 // No ideal or maximum frame rate given, expect default.
1343 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1344 // kMinFrameRate should be ignored.
1345 EXPECT_FALSE(result.min_frame_rate().has_value());
1346 EXPECT_FALSE(result.max_frame_rate().has_value());
1347 CheckNonFrameRateDefaults(result);
1348 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1349 }
1350
1351 // MinFrameRate equal to the minimum allowed.
1352 {
1353 const double kMinFrameRate = 0.0;
1354 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1355 auto result = SelectSettings();
1356 EXPECT_TRUE(result.HasValue());
1357 // No ideal or maximum frame rate given, expect default.
1358 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1359 EXPECT_TRUE(result.min_frame_rate().has_value());
1360 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1361 EXPECT_FALSE(result.max_frame_rate().has_value());
1362 CheckNonFrameRateDefaults(result);
1363 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1364 }
1365 }
1366
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryMaxFrameRate)1367 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryMaxFrameRate) {
1368 constraint_factory_.Reset();
1369 // kMaxFrameRate greater than default
1370 {
1371 const double kMaxFrameRate = 45.0;
1372 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1373 auto result = SelectSettings();
1374 EXPECT_TRUE(result.HasValue());
1375 // If max frame rate is provided, it is used as default.
1376 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1377 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1378 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1379 CheckNonFrameRateDefaults(result);
1380 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1381 kMaxFrameRate);
1382 }
1383
1384 // kMaxFrameRate less than default
1385 {
1386 const double kMaxFrameRate = 5.0;
1387 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1388 auto result = SelectSettings();
1389 EXPECT_TRUE(result.HasValue());
1390 // If max frame rate is provided, it is used as default.
1391 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1392 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1393 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1394 CheckNonFrameRateDefaults(result);
1395 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1396 kMaxFrameRate);
1397 }
1398
1399 // kMaxFrameRate greater than the maximum allowed
1400 {
1401 const double kMaxFrameRate = kMaxScreenCastFrameRate + 0.1;
1402 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1403 auto result = SelectSettings();
1404 EXPECT_TRUE(result.HasValue());
1405 // Expect the default, since the given maximum is invalid.
1406 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1407 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1408 EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
1409 CheckNonFrameRateDefaults(result);
1410 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1411 }
1412
1413 // kMaxFrameRate equal to the maximum allowed
1414 {
1415 const double kMaxFrameRate = kMaxScreenCastFrameRate;
1416 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1417 auto result = SelectSettings();
1418 EXPECT_TRUE(result.HasValue());
1419 // If max frame rate is provided, it is used as default.
1420 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1421 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1422 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1423 CheckNonFrameRateDefaults(result);
1424 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1425 kMaxFrameRate);
1426 }
1427 }
1428
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryRangeFrameRate)1429 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryRangeFrameRate) {
1430 constraint_factory_.Reset();
1431 {
1432 const double kMinFrameRate = 15.0;
1433 const double kMaxFrameRate = 45.0;
1434 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1435 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1436 auto result = SelectSettings();
1437 EXPECT_TRUE(result.HasValue());
1438 // If max frame rate is provided, it is used as default.
1439 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1440 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1441 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1442 CheckNonFrameRateDefaults(result);
1443 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1444 kMaxFrameRate);
1445 }
1446
1447 {
1448 const double kMinFrameRate = 45.0;
1449 const double kMaxFrameRate = 55.0;
1450 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1451 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1452 auto result = SelectSettings();
1453 EXPECT_TRUE(result.HasValue());
1454 // If max frame rate is provided, it is used as default.
1455 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1456 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1457 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1458 CheckNonFrameRateDefaults(result);
1459 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1460 kMaxFrameRate);
1461 }
1462
1463 {
1464 const double kMinFrameRate = 10.0;
1465 const double kMaxFrameRate = 15.0;
1466 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1467 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1468 auto result = SelectSettings();
1469 EXPECT_TRUE(result.HasValue());
1470 // If max frame rate is provided, it is used as default.
1471 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1472 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1473 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1474 CheckNonFrameRateDefaults(result);
1475 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1476 kMaxFrameRate);
1477 }
1478 }
1479
TEST_F(MediaStreamConstraintsUtilVideoContentTest,IdealFrameRate)1480 TEST_F(MediaStreamConstraintsUtilVideoContentTest, IdealFrameRate) {
1481 // Unconstrained.
1482 {
1483 constraint_factory_.Reset();
1484 const double kIdealFrameRate = 45.0;
1485 constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
1486 auto result = SelectSettings();
1487 EXPECT_TRUE(result.HasValue());
1488 EXPECT_EQ(kIdealFrameRate, result.FrameRate());
1489 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1490 EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
1491 CheckNonFrameRateDefaults(result);
1492 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1493 kIdealFrameRate);
1494 }
1495
1496 // Ideal greater than maximum.
1497 {
1498 constraint_factory_.Reset();
1499 const double kIdealFrameRate = 45.0;
1500 const double kMaxFrameRate = 30.0;
1501 constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
1502 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1503 auto result = SelectSettings();
1504 EXPECT_TRUE(result.HasValue());
1505 EXPECT_EQ(kMaxFrameRate, result.FrameRate());
1506 EXPECT_EQ(base::Optional<double>(), result.min_frame_rate());
1507 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1508 CheckNonFrameRateDefaults(result);
1509 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1510 kMaxFrameRate);
1511 }
1512
1513 // Ideal less than minimum.
1514 {
1515 constraint_factory_.Reset();
1516 const double kIdealFrameRate = 45.0;
1517 const double kMinFrameRate = 50.0;
1518 constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
1519 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1520 auto result = SelectSettings();
1521 EXPECT_TRUE(result.HasValue());
1522 EXPECT_EQ(kMinFrameRate, result.FrameRate());
1523 EXPECT_EQ(base::Optional<double>(), result.max_frame_rate());
1524 CheckNonFrameRateDefaults(result);
1525 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1526 kMinFrameRate);
1527 }
1528
1529 // Ideal within range.
1530 {
1531 constraint_factory_.Reset();
1532 const double kIdealFrameRate = 45.0;
1533 const double kMinFrameRate = 35.0;
1534 const double kMaxFrameRate = 50.0;
1535 constraint_factory_.basic().frame_rate.SetIdeal(kIdealFrameRate);
1536 constraint_factory_.basic().frame_rate.SetMin(kMinFrameRate);
1537 constraint_factory_.basic().frame_rate.SetMax(kMaxFrameRate);
1538 auto result = SelectSettings();
1539 EXPECT_TRUE(result.HasValue());
1540 EXPECT_EQ(kIdealFrameRate, result.FrameRate());
1541 EXPECT_EQ(kMinFrameRate, result.min_frame_rate());
1542 EXPECT_EQ(kMaxFrameRate, result.max_frame_rate());
1543 CheckNonFrameRateDefaults(result);
1544 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result,
1545 kIdealFrameRate);
1546 }
1547 }
1548
TEST_F(MediaStreamConstraintsUtilVideoContentTest,MandatoryResizeMode)1549 TEST_F(MediaStreamConstraintsUtilVideoContentTest, MandatoryResizeMode) {
1550 const int kIdealWidth = 641;
1551 const int kIdealHeight = 480;
1552 constraint_factory_.Reset();
1553 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
1554 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
1555 constraint_factory_.basic().resize_mode.SetExact("none");
1556 auto result = SelectSettings();
1557 EXPECT_TRUE(result.HasValue());
1558 // Screen capture will proceed at 641x480, which will be considered "native".
1559 // No rescaling will occur since it is explicitly disabled.
1560 EXPECT_EQ(result.Width(), kIdealWidth);
1561 EXPECT_EQ(result.Height(), kIdealHeight);
1562 EXPECT_FALSE(result.track_adapter_settings().target_size().has_value());
1563
1564 constraint_factory_.basic().resize_mode.SetExact("crop-and-scale");
1565 result = SelectSettings();
1566 EXPECT_TRUE(result.HasValue());
1567 EXPECT_EQ(result.Width(), kIdealWidth);
1568 EXPECT_EQ(result.Height(), kIdealHeight);
1569 EXPECT_EQ(result.track_adapter_settings().target_width(), kIdealWidth);
1570 EXPECT_EQ(result.track_adapter_settings().target_height(), kIdealHeight);
1571 }
1572
1573 // The "Advanced" tests check selection criteria involving advanced constraint
1574 // sets.
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedMinMaxResolutionFrameRate)1575 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1576 AdvancedMinMaxResolutionFrameRate) {
1577 constraint_factory_.Reset();
1578 MediaTrackConstraintSetPlatform& advanced1 =
1579 constraint_factory_.AddAdvanced();
1580 advanced1.width.SetMin(2000000000);
1581 advanced1.height.SetMin(2000000000);
1582 // The first advanced set cannot be satisfied and is therefore ignored in all
1583 // calls to SelectSettings().
1584 // In this case, default settings must be selected.
1585 auto result = SelectSettings();
1586 EXPECT_TRUE(result.HasValue());
1587 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1588 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1589 CheckNonResolutionDefaults(result);
1590 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1591
1592 MediaTrackConstraintSetPlatform& advanced2 =
1593 constraint_factory_.AddAdvanced();
1594 advanced2.height.SetMax(400);
1595 advanced2.width.SetMax(500);
1596 advanced2.aspect_ratio.SetExact(5.0 / 4.0);
1597 result = SelectSettings();
1598 EXPECT_TRUE(result.HasValue());
1599 EXPECT_EQ(400, result.Height());
1600 EXPECT_EQ(500, result.Width());
1601 CheckNonResolutionDefaults(result);
1602 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio());
1603 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio());
1604 CheckTrackAdapterSettingsEqualsFormat(result);
1605
1606 MediaTrackConstraintSetPlatform& advanced3 =
1607 constraint_factory_.AddAdvanced();
1608 advanced3.frame_rate.SetMax(10.0);
1609 result = SelectSettings();
1610 EXPECT_TRUE(result.HasValue());
1611 // The third advanced set is supported in addition to the previous set.
1612 EXPECT_EQ(400, result.Height());
1613 EXPECT_EQ(500, result.Width());
1614 EXPECT_EQ(10.0, result.FrameRate());
1615 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
1616 EXPECT_EQ(std::string(), result.device_id());
1617 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio());
1618 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio());
1619 CheckTrackAdapterSettingsEqualsFormat(result, 10.0);
1620
1621 MediaTrackConstraintSetPlatform& advanced4 =
1622 constraint_factory_.AddAdvanced();
1623 advanced4.width.SetExact(1000);
1624 advanced4.height.SetExact(1000);
1625 result = SelectSettings();
1626 // The fourth advanced set cannot be supported in combination with the
1627 // previous two sets, so it must be ignored.
1628 EXPECT_TRUE(result.HasValue());
1629 EXPECT_EQ(400, result.Height());
1630 EXPECT_EQ(500, result.Width());
1631 EXPECT_EQ(10.0, result.FrameRate());
1632 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
1633 EXPECT_EQ(std::string(), result.device_id());
1634 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio());
1635 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio());
1636 CheckTrackAdapterSettingsEqualsFormat(result, 10.0);
1637
1638 constraint_factory_.basic().width.SetIdeal(100);
1639 constraint_factory_.basic().height.SetIdeal(100);
1640 result = SelectSettings();
1641 EXPECT_TRUE(result.HasValue());
1642 // The closest point to (100, 100) that satisfies all previous constraint
1643 // sets is its projection on the aspect-ratio line 5.0/4.0.
1644 // This is a point m*(4, 5) such that Dot((4,5), (100 - m(4,5))) == 0.
1645 // This works out to be m = 900/41.
1646 EXPECT_EQ(std::round(4.0 * 900.0 / 41.0), result.Height());
1647 EXPECT_EQ(std::round(5.0 * 900.0 / 41.0), result.Width());
1648 EXPECT_EQ(10.0, result.FrameRate());
1649 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
1650 EXPECT_EQ(std::string(), result.device_id());
1651 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio());
1652 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio());
1653 CheckTrackAdapterSettingsEqualsFormat(result, 10.0);
1654
1655 constraint_factory_.basic().width.SetIdeal(2000);
1656 constraint_factory_.basic().height.SetIdeal(1500);
1657 result = SelectSettings();
1658 EXPECT_TRUE(result.HasValue());
1659 // The projection of (2000,1500) on the aspect-ratio line 5.0/4.0 is beyond
1660 // the maximum of (400, 500), so use the maximum allowed resolution.
1661 EXPECT_TRUE(result.HasValue());
1662 EXPECT_EQ(400, result.Height());
1663 EXPECT_EQ(500, result.Width());
1664 EXPECT_EQ(10.0, result.FrameRate());
1665 EXPECT_EQ(base::Optional<bool>(), result.noise_reduction());
1666 EXPECT_EQ(std::string(), result.device_id());
1667 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().min_aspect_ratio());
1668 EXPECT_EQ(5.0 / 4.0, result.track_adapter_settings().max_aspect_ratio());
1669 CheckTrackAdapterSettingsEqualsFormat(result, 10.0);
1670 }
1671
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedExactResolution)1672 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedExactResolution) {
1673 {
1674 constraint_factory_.Reset();
1675 MediaTrackConstraintSetPlatform& advanced1 =
1676 constraint_factory_.AddAdvanced();
1677 advanced1.width.SetExact(40000000);
1678 advanced1.height.SetExact(40000000);
1679 MediaTrackConstraintSetPlatform& advanced2 =
1680 constraint_factory_.AddAdvanced();
1681 advanced2.width.SetExact(300000000);
1682 advanced2.height.SetExact(300000000);
1683 auto result = SelectSettings();
1684 // None of the constraint sets can be satisfied. Default resolution should
1685 // be selected.
1686 EXPECT_TRUE(result.HasValue());
1687 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1688 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
1689 CheckNonResolutionDefaults(result);
1690 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1691
1692 MediaTrackConstraintSetPlatform& advanced3 =
1693 constraint_factory_.AddAdvanced();
1694 advanced3.width.SetExact(1920);
1695 advanced3.height.SetExact(1080);
1696 result = SelectSettings();
1697 EXPECT_TRUE(result.HasValue());
1698 EXPECT_EQ(1920, result.Width());
1699 EXPECT_EQ(1080, result.Height());
1700 CheckNonResolutionDefaults(result);
1701 EXPECT_EQ(1920.0 / 1080.0,
1702 result.track_adapter_settings().min_aspect_ratio());
1703 EXPECT_EQ(1920.0 / 1080.0,
1704 result.track_adapter_settings().max_aspect_ratio());
1705 CheckTrackAdapterSettingsEqualsFormat(result);
1706
1707 MediaTrackConstraintSetPlatform& advanced4 =
1708 constraint_factory_.AddAdvanced();
1709 advanced4.width.SetExact(640);
1710 advanced4.height.SetExact(480);
1711 result = SelectSettings();
1712 // The fourth constraint set contradicts the third set. The fourth set
1713 // should be ignored.
1714 EXPECT_TRUE(result.HasValue());
1715 EXPECT_EQ(1920, result.Width());
1716 EXPECT_EQ(1080, result.Height());
1717 CheckNonResolutionDefaults(result);
1718 EXPECT_EQ(1920.0 / 1080.0,
1719 result.track_adapter_settings().min_aspect_ratio());
1720 EXPECT_EQ(1920.0 / 1080.0,
1721 result.track_adapter_settings().max_aspect_ratio());
1722 CheckTrackAdapterSettingsEqualsFormat(result);
1723
1724 constraint_factory_.basic().width.SetIdeal(800);
1725 constraint_factory_.basic().height.SetIdeal(600);
1726 result = SelectSettings();
1727 EXPECT_TRUE(result.HasValue());
1728 // The exact constraints has priority over ideal.
1729 EXPECT_EQ(1920, result.Width());
1730 EXPECT_EQ(1080, result.Height());
1731 CheckNonResolutionDefaults(result);
1732 EXPECT_EQ(1920.0 / 1080.0,
1733 result.track_adapter_settings().min_aspect_ratio());
1734 EXPECT_EQ(1920.0 / 1080.0,
1735 result.track_adapter_settings().max_aspect_ratio());
1736 CheckTrackAdapterSettingsEqualsFormat(result);
1737 }
1738 }
1739
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedResolutionAndFrameRate)1740 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1741 AdvancedResolutionAndFrameRate) {
1742 constraint_factory_.Reset();
1743 MediaTrackConstraintSetPlatform& advanced1 =
1744 constraint_factory_.AddAdvanced();
1745 advanced1.width.SetExact(1920);
1746 advanced1.height.SetExact(1080);
1747 MediaTrackConstraintSetPlatform& advanced2 =
1748 constraint_factory_.AddAdvanced();
1749 advanced2.frame_rate.SetExact(60.0);
1750 auto result = SelectSettings();
1751 EXPECT_TRUE(result.HasValue());
1752 EXPECT_EQ(1920, result.Width());
1753 EXPECT_EQ(1080, result.Height());
1754 EXPECT_EQ(60.0, result.FrameRate());
1755 EXPECT_EQ(1920.0 / 1080.0,
1756 result.track_adapter_settings().min_aspect_ratio());
1757 EXPECT_EQ(1920.0 / 1080.0,
1758 result.track_adapter_settings().max_aspect_ratio());
1759 CheckTrackAdapterSettingsEqualsFormat(result, 60.0);
1760 }
1761
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedNoiseReduction)1762 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedNoiseReduction) {
1763 constraint_factory_.Reset();
1764 MediaTrackConstraintSetPlatform& advanced1 =
1765 constraint_factory_.AddAdvanced();
1766 advanced1.width.SetMin(640);
1767 advanced1.height.SetMin(480);
1768 MediaTrackConstraintSetPlatform& advanced2 =
1769 constraint_factory_.AddAdvanced();
1770 const int kMinWidth = 4000;
1771 const int kMinHeight = 2000;
1772 advanced2.width.SetMin(kMinWidth);
1773 advanced2.height.SetMin(kMinHeight);
1774 advanced2.goog_noise_reduction.SetExact(false);
1775 auto result = SelectSettings();
1776 EXPECT_TRUE(result.HasValue());
1777 EXPECT_EQ(kMinWidth, result.Width());
1778 // Preserves default aspect ratio.
1779 EXPECT_EQ(static_cast<int>(
1780 std::round(result.Width() / kDefaultScreenCastAspectRatio)),
1781 result.Height());
1782 EXPECT_TRUE(result.noise_reduction() && !*result.noise_reduction());
1783 EXPECT_EQ(kMinWidth / static_cast<double>(kMaxScreenCastDimension),
1784 result.track_adapter_settings().min_aspect_ratio());
1785 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
1786 result.track_adapter_settings().max_aspect_ratio());
1787 CheckTrackAdapterSettingsEqualsFormat(result);
1788 }
1789
1790 // The "AdvancedContradictory" tests check that advanced constraint sets that
1791 // contradict previous constraint sets are ignored.
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryNoiseReduction)1792 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1793 AdvancedContradictoryNoiseReduction) {
1794 constraint_factory_.Reset();
1795 MediaTrackConstraintSetPlatform& advanced1 =
1796 constraint_factory_.AddAdvanced();
1797 advanced1.width.SetExact(640);
1798 advanced1.height.SetExact(480);
1799 advanced1.goog_noise_reduction.SetExact(true);
1800 MediaTrackConstraintSetPlatform& advanced2 =
1801 constraint_factory_.AddAdvanced();
1802 advanced2.width.SetExact(1920);
1803 advanced2.height.SetExact(1080);
1804 advanced2.goog_noise_reduction.SetExact(false);
1805 auto result = SelectSettings();
1806 EXPECT_TRUE(result.HasValue());
1807 EXPECT_EQ(640, result.Width());
1808 EXPECT_EQ(480, result.Height());
1809 EXPECT_TRUE(result.noise_reduction() && *result.noise_reduction());
1810 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio());
1811 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio());
1812 CheckTrackAdapterSettingsEqualsFormat(result);
1813 }
1814
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryExactResolution)1815 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1816 AdvancedContradictoryExactResolution) {
1817 constraint_factory_.Reset();
1818 MediaTrackConstraintSetPlatform& advanced1 =
1819 constraint_factory_.AddAdvanced();
1820 advanced1.width.SetExact(640);
1821 advanced1.height.SetExact(480);
1822 MediaTrackConstraintSetPlatform& advanced2 =
1823 constraint_factory_.AddAdvanced();
1824 advanced2.width.SetExact(1920);
1825 advanced2.height.SetExact(1080);
1826 auto result = SelectSettings();
1827 EXPECT_TRUE(result.HasValue());
1828 EXPECT_EQ(640, result.Width());
1829 EXPECT_EQ(480, result.Height());
1830 CheckNonResolutionDefaults(result);
1831 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio());
1832 EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio());
1833 CheckTrackAdapterSettingsEqualsFormat(result);
1834 }
1835
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryMaxMinResolutionFrameRate)1836 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1837 AdvancedContradictoryMaxMinResolutionFrameRate) {
1838 constraint_factory_.Reset();
1839 MediaTrackConstraintSetPlatform& advanced1 =
1840 constraint_factory_.AddAdvanced();
1841 advanced1.width.SetMax(640);
1842 advanced1.height.SetMax(480);
1843 MediaTrackConstraintSetPlatform& advanced2 =
1844 constraint_factory_.AddAdvanced();
1845 advanced2.width.SetMin(1920);
1846 advanced2.height.SetMin(1080);
1847 advanced2.frame_rate.SetExact(60.0);
1848 auto result = SelectSettings();
1849 EXPECT_TRUE(result.HasValue());
1850 EXPECT_EQ(640, result.Width());
1851 EXPECT_EQ(480, result.Height());
1852 // Resolution cannot exceed the requested resolution.
1853 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1854 EXPECT_EQ(kMinScreenCastDimension / 480.0,
1855 result.track_adapter_settings().min_aspect_ratio());
1856 EXPECT_EQ(640.0 / kMinScreenCastDimension,
1857 result.track_adapter_settings().max_aspect_ratio());
1858 CheckTrackAdapterSettingsEqualsFormat(result);
1859 }
1860
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryMinMaxResolutionFrameRate)1861 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1862 AdvancedContradictoryMinMaxResolutionFrameRate) {
1863 const int kMinHeight = 2600;
1864 const int kMinWidth = 2800;
1865 constraint_factory_.Reset();
1866 MediaTrackConstraintSetPlatform& advanced1 =
1867 constraint_factory_.AddAdvanced();
1868 advanced1.width.SetMin(kMinWidth);
1869 advanced1.height.SetMin(kMinHeight);
1870 MediaTrackConstraintSetPlatform& advanced2 =
1871 constraint_factory_.AddAdvanced();
1872 advanced2.width.SetMax(640);
1873 advanced2.height.SetMax(480);
1874 advanced2.frame_rate.SetExact(60.0);
1875 auto result = SelectSettings();
1876 EXPECT_TRUE(result.HasValue());
1877 EXPECT_EQ(std::round(kMinHeight * kDefaultScreenCastAspectRatio),
1878 result.Width());
1879 EXPECT_EQ(kMinHeight, result.Height());
1880 EXPECT_EQ(kDefaultScreenCastFrameRate, result.FrameRate());
1881 EXPECT_EQ(static_cast<double>(kMinWidth) / kMaxScreenCastDimension,
1882 result.track_adapter_settings().min_aspect_ratio());
1883 EXPECT_EQ(static_cast<double>(kMaxScreenCastDimension) / kMinHeight,
1884 result.track_adapter_settings().max_aspect_ratio());
1885 CheckTrackAdapterSettingsEqualsFormat(result);
1886 }
1887
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryExactAspectRatio)1888 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1889 AdvancedContradictoryExactAspectRatio) {
1890 constraint_factory_.Reset();
1891 MediaTrackConstraintSetPlatform& advanced1 =
1892 constraint_factory_.AddAdvanced();
1893 const double kMinAspectRatio = 5.0;
1894 advanced1.aspect_ratio.SetExact(kMinAspectRatio);
1895 MediaTrackConstraintSetPlatform& advanced2 =
1896 constraint_factory_.AddAdvanced();
1897 advanced2.aspect_ratio.SetExact(3.0);
1898 auto result = SelectSettings();
1899 EXPECT_TRUE(result.HasValue());
1900 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio),
1901 result.Width());
1902 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1903 CheckNonResolutionDefaults(result);
1904 EXPECT_EQ(kMinAspectRatio,
1905 result.track_adapter_settings().min_aspect_ratio());
1906 EXPECT_EQ(kMinAspectRatio,
1907 result.track_adapter_settings().max_aspect_ratio());
1908 CheckTrackAdapterSettingsEqualsFormat(result);
1909 }
1910
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryAspectRatioRange)1911 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1912 AdvancedContradictoryAspectRatioRange) {
1913 constraint_factory_.Reset();
1914 MediaTrackConstraintSetPlatform& advanced1 =
1915 constraint_factory_.AddAdvanced();
1916 const double kMinAspectRatio = 5.0;
1917 advanced1.aspect_ratio.SetMin(kMinAspectRatio);
1918 MediaTrackConstraintSetPlatform& advanced2 =
1919 constraint_factory_.AddAdvanced();
1920 advanced2.aspect_ratio.SetMax(3.0);
1921 auto result = SelectSettings();
1922 EXPECT_TRUE(result.HasValue());
1923 EXPECT_EQ(std::round(kDefaultScreenCastHeight * kMinAspectRatio),
1924 result.Width());
1925 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
1926 CheckNonResolutionDefaults(result);
1927 EXPECT_EQ(kMinAspectRatio,
1928 result.track_adapter_settings().min_aspect_ratio());
1929 EXPECT_EQ(
1930 kMaxScreenCastDimension / static_cast<double>(kMinScreenCastDimension),
1931 result.track_adapter_settings().max_aspect_ratio());
1932 CheckTrackAdapterSettingsEqualsFormat(result);
1933 }
1934
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryExactFrameRate)1935 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1936 AdvancedContradictoryExactFrameRate) {
1937 constraint_factory_.Reset();
1938 MediaTrackConstraintSetPlatform& advanced1 =
1939 constraint_factory_.AddAdvanced();
1940 advanced1.frame_rate.SetExact(40.0);
1941 MediaTrackConstraintSetPlatform& advanced2 =
1942 constraint_factory_.AddAdvanced();
1943 advanced2.frame_rate.SetExact(45.0);
1944 auto result = SelectSettings();
1945 EXPECT_TRUE(result.HasValue());
1946 EXPECT_EQ(40.0, result.FrameRate());
1947 CheckNonFrameRateDefaults(result);
1948 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result, 40.0);
1949 }
1950
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryFrameRateRange)1951 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1952 AdvancedContradictoryFrameRateRange) {
1953 constraint_factory_.Reset();
1954 MediaTrackConstraintSetPlatform& advanced1 =
1955 constraint_factory_.AddAdvanced();
1956 advanced1.frame_rate.SetMin(40.0);
1957 MediaTrackConstraintSetPlatform& advanced2 =
1958 constraint_factory_.AddAdvanced();
1959 advanced2.frame_rate.SetMax(35.0);
1960 auto result = SelectSettings();
1961 EXPECT_TRUE(result.HasValue());
1962 EXPECT_LE(40.0, result.FrameRate());
1963 CheckNonFrameRateDefaults(result);
1964 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
1965 }
1966
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryWidthFrameRate)1967 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1968 AdvancedContradictoryWidthFrameRate) {
1969 const int kMaxWidth = 1920;
1970 constraint_factory_.Reset();
1971 MediaTrackConstraintSetPlatform& advanced1 =
1972 constraint_factory_.AddAdvanced();
1973 advanced1.width.SetMax(kMaxWidth);
1974 MediaTrackConstraintSetPlatform& advanced2 =
1975 constraint_factory_.AddAdvanced();
1976 advanced2.width.SetMin(2000);
1977 advanced2.frame_rate.SetExact(10.0);
1978 MediaTrackConstraintSetPlatform& advanced3 =
1979 constraint_factory_.AddAdvanced();
1980 advanced3.frame_rate.SetExact(90.0);
1981 auto result = SelectSettings();
1982 EXPECT_TRUE(result.HasValue());
1983 EXPECT_EQ(kMaxWidth, result.Width());
1984 EXPECT_EQ(std::round(kMaxWidth / kDefaultScreenCastAspectRatio),
1985 result.Height());
1986 EXPECT_EQ(90.0, result.FrameRate());
1987 EXPECT_EQ(
1988 static_cast<double>(kMinScreenCastDimension) / kMaxScreenCastDimension,
1989 result.track_adapter_settings().min_aspect_ratio());
1990 EXPECT_EQ(static_cast<double>(kMaxWidth) / kMinScreenCastDimension,
1991 result.track_adapter_settings().max_aspect_ratio());
1992 CheckTrackAdapterSettingsEqualsFormat(result, 90.0);
1993 }
1994
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryHeightFrameRate)1995 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
1996 AdvancedContradictoryHeightFrameRate) {
1997 const int kMaxHeight = 2000;
1998 constraint_factory_.Reset();
1999 MediaTrackConstraintSetPlatform& advanced1 =
2000 constraint_factory_.AddAdvanced();
2001 advanced1.height.SetMax(kMaxHeight);
2002 MediaTrackConstraintSetPlatform& advanced2 =
2003 constraint_factory_.AddAdvanced();
2004 advanced2.height.SetMin(4500);
2005 advanced2.frame_rate.SetExact(10.0);
2006 MediaTrackConstraintSetPlatform& advanced3 =
2007 constraint_factory_.AddAdvanced();
2008 advanced3.frame_rate.SetExact(60.0);
2009 auto result = SelectSettings();
2010 EXPECT_TRUE(result.HasValue());
2011 EXPECT_EQ(kMaxHeight * kDefaultScreenCastAspectRatio, result.Width());
2012 // Height defaults to explicitly given max constraint.
2013 EXPECT_EQ(kMaxHeight, result.Height());
2014 EXPECT_EQ(60.0, result.FrameRate());
2015 EXPECT_EQ(static_cast<double>(kMinScreenCastDimension) / kMaxHeight,
2016 result.track_adapter_settings().min_aspect_ratio());
2017 EXPECT_EQ(
2018 static_cast<double>(kMaxScreenCastDimension) / kMinScreenCastDimension,
2019 result.track_adapter_settings().max_aspect_ratio());
2020 CheckTrackAdapterSettingsEqualsFormat(result, 60.0);
2021 }
2022
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedDeviceID)2023 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedDeviceID) {
2024 const String kDeviceID1 = "fake_device_1";
2025 const String kDeviceID2 = "fake_device_2";
2026 const String kDeviceID3 = "fake_device_3";
2027 const String kDeviceID4 = "fake_device_4";
2028 constraint_factory_.Reset();
2029 MediaTrackConstraintSetPlatform& advanced1 =
2030 constraint_factory_.AddAdvanced();
2031 Vector<String> id_vector1 = {kDeviceID1, kDeviceID2};
2032 advanced1.device_id.SetExact(id_vector1);
2033 Vector<String> id_vector2 = {kDeviceID2, kDeviceID3};
2034 MediaTrackConstraintSetPlatform& advanced2 =
2035 constraint_factory_.AddAdvanced();
2036 advanced2.device_id.SetExact(id_vector2);
2037 auto result = SelectSettings();
2038 EXPECT_TRUE(result.HasValue());
2039 // kDeviceID2 must be selected because it is the only one that satisfies both
2040 // advanced sets.
2041 EXPECT_EQ(kDeviceID2.Utf8(), result.device_id());
2042 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2043 }
2044
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedContradictoryDeviceID)2045 TEST_F(MediaStreamConstraintsUtilVideoContentTest,
2046 AdvancedContradictoryDeviceID) {
2047 const String kDeviceID1 = "fake_device_1";
2048 const String kDeviceID2 = "fake_device_2";
2049 const String kDeviceID3 = "fake_device_3";
2050 const String kDeviceID4 = "fake_device_4";
2051 constraint_factory_.Reset();
2052 MediaTrackConstraintSetPlatform& advanced1 =
2053 constraint_factory_.AddAdvanced();
2054 Vector<String> id_vector1 = {kDeviceID1, kDeviceID2};
2055 advanced1.device_id.SetExact(id_vector1);
2056 Vector<String> id_vector2 = {kDeviceID3, kDeviceID4};
2057 MediaTrackConstraintSetPlatform& advanced2 =
2058 constraint_factory_.AddAdvanced();
2059 advanced2.device_id.SetExact(id_vector2);
2060 auto result = SelectSettings();
2061 EXPECT_TRUE(result.HasValue());
2062 // The second advanced set must be ignored because it contradicts the first
2063 // set.
2064 EXPECT_EQ(kDeviceID1.Utf8(), result.device_id());
2065 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2066 }
2067
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedIdealDeviceID)2068 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedIdealDeviceID) {
2069 const String kDeviceID1 = "fake_device_1";
2070 const String kDeviceID2 = "fake_device_2";
2071 const String kDeviceID3 = "fake_device_3";
2072 constraint_factory_.Reset();
2073 MediaTrackConstraintSetPlatform& advanced = constraint_factory_.AddAdvanced();
2074 Vector<String> id_vector1 = {kDeviceID1, kDeviceID2};
2075 advanced.device_id.SetExact(id_vector1);
2076
2077 Vector<String> id_vector2 = {kDeviceID2, kDeviceID3};
2078 constraint_factory_.basic().device_id.SetIdeal(id_vector2);
2079 auto result = SelectSettings();
2080 EXPECT_TRUE(result.HasValue());
2081 // Should select kDeviceID2, which appears in ideal and satisfies the advanced
2082 // set.
2083 EXPECT_EQ(kDeviceID2.Utf8(), result.device_id());
2084 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2085 }
2086
TEST_F(MediaStreamConstraintsUtilVideoContentTest,AdvancedResizeMode)2087 TEST_F(MediaStreamConstraintsUtilVideoContentTest, AdvancedResizeMode) {
2088 const int kIdealWidth = 641;
2089 const int kIdealHeight = 480;
2090 constraint_factory_.Reset();
2091 constraint_factory_.basic().width.SetIdeal(kIdealWidth);
2092 constraint_factory_.basic().height.SetIdeal(kIdealHeight);
2093 MediaTrackConstraintSetPlatform& advanced = constraint_factory_.AddAdvanced();
2094 advanced.resize_mode.SetExact("none");
2095 auto result = SelectSettings();
2096 EXPECT_TRUE(result.HasValue());
2097 // Screen capture will proceed at 641x480, which will be considered "native".
2098 // No rescaling will occur since it is explicitly disabled in the advanced
2099 // constraint set.
2100 EXPECT_EQ(result.Width(), kIdealWidth);
2101 EXPECT_EQ(result.Height(), kIdealHeight);
2102 EXPECT_FALSE(result.track_adapter_settings().target_size().has_value());
2103
2104 advanced.resize_mode.SetExact("crop-and-scale");
2105 result = SelectSettings();
2106 EXPECT_TRUE(result.HasValue());
2107 // Screen capture will proceed at 641x480, which will be considered "native".
2108 // No rescaling will occur since it is explicitly disabled in the advanced
2109 // constraint set.
2110 EXPECT_EQ(result.Width(), kIdealWidth);
2111 EXPECT_EQ(result.Height(), kIdealHeight);
2112 EXPECT_TRUE(result.track_adapter_settings().target_size().has_value());
2113 EXPECT_EQ(result.track_adapter_settings().target_width(), kIdealWidth);
2114 EXPECT_EQ(result.track_adapter_settings().target_height(), kIdealHeight);
2115 }
2116
TEST_F(MediaStreamConstraintsUtilVideoContentTest,ResolutionChangePolicy)2117 TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
2118 {
2119 constraint_factory_.Reset();
2120 auto result = SelectSettings();
2121 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
2122 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
2123 // Resolution can be adjusted.
2124 EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
2125 result.ResolutionChangePolicy());
2126 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2127 }
2128 {
2129 constraint_factory_.Reset();
2130 auto result = SelectSettings(mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE);
2131 EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
2132 EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
2133 // Default policy for tab capture is fixed resolution.
2134 EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
2135 result.ResolutionChangePolicy());
2136 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2137 }
2138 {
2139 constraint_factory_.Reset();
2140 constraint_factory_.basic().width.SetIdeal(630);
2141 constraint_factory_.basic().height.SetIdeal(470);
2142 auto result = SelectSettings();
2143 EXPECT_EQ(630, result.Width());
2144 EXPECT_EQ(470, result.Height());
2145 // Resolution can be adjusted because ideal was used to select the
2146 // resolution.
2147 EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
2148 result.ResolutionChangePolicy());
2149 CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
2150 }
2151 {
2152 constraint_factory_.Reset();
2153 constraint_factory_.basic().width.SetExact(640);
2154 constraint_factory_.basic().height.SetExact(480);
2155 auto result = SelectSettings();
2156 EXPECT_EQ(640, result.Width());
2157 EXPECT_EQ(480, result.Height());
2158 EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
2159 result.ResolutionChangePolicy());
2160 EXPECT_EQ(640.0 / 480.0,
2161 result.track_adapter_settings().min_aspect_ratio());
2162 EXPECT_EQ(640.0 / 480.0,
2163 result.track_adapter_settings().max_aspect_ratio());
2164 CheckTrackAdapterSettingsEqualsFormat(result);
2165 }
2166 {
2167 constraint_factory_.Reset();
2168 constraint_factory_.basic().width.SetExact(1000);
2169 constraint_factory_.basic().height.SetExact(500);
2170 auto result = SelectSettings();
2171 EXPECT_EQ(1000, result.Width());
2172 EXPECT_EQ(500, result.Height());
2173 EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
2174 result.ResolutionChangePolicy());
2175 EXPECT_EQ(1000.0 / 500.0,
2176 result.track_adapter_settings().min_aspect_ratio());
2177 EXPECT_EQ(1000.0 / 500.0,
2178 result.track_adapter_settings().max_aspect_ratio());
2179 CheckTrackAdapterSettingsEqualsFormat(result);
2180 }
2181 {
2182 constraint_factory_.Reset();
2183 constraint_factory_.basic().width.SetExact(630);
2184 constraint_factory_.basic().height.SetExact(470);
2185 auto result = SelectSettings();
2186 EXPECT_EQ(630, result.Width());
2187 EXPECT_EQ(470, result.Height());
2188 EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
2189 result.ResolutionChangePolicy());
2190 EXPECT_EQ(630.0 / 470.0,
2191 result.track_adapter_settings().min_aspect_ratio());
2192 EXPECT_EQ(630.0 / 470.0,
2193 result.track_adapter_settings().max_aspect_ratio());
2194 CheckTrackAdapterSettingsEqualsFormat(result);
2195 }
2196 {
2197 constraint_factory_.Reset();
2198 constraint_factory_.basic().width.SetMax(800);
2199 constraint_factory_.basic().height.SetMax(600);
2200 constraint_factory_.basic().width.SetMin(400);
2201 constraint_factory_.basic().height.SetMin(300);
2202 auto result = SelectSettings();
2203 EXPECT_EQ(800, result.Width());
2204 EXPECT_EQ(600, result.Height());
2205 // When the aspect ratio of the max resolution equals the aspect ratio of
2206 // the min resolution, the algorithm sets fixed aspect ratio policy.
2207 EXPECT_EQ(media::ResolutionChangePolicy::FIXED_ASPECT_RATIO,
2208 result.ResolutionChangePolicy());
2209 CheckTrackAdapterSettingsEqualsFormat(result);
2210 }
2211 {
2212 constraint_factory_.Reset();
2213 constraint_factory_.basic().width.SetMax(800);
2214 constraint_factory_.basic().height.SetMax(600);
2215 constraint_factory_.basic().width.SetMin(400);
2216 constraint_factory_.basic().height.SetMin(400);
2217 auto result = SelectSettings();
2218 EXPECT_EQ(800, result.Width());
2219 EXPECT_EQ(600, result.Height());
2220 // When the aspect ratio of the max resolution differs from the aspect ratio
2221 // of the min resolution, the algorithm sets any-within-limit policy.
2222 EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
2223 result.ResolutionChangePolicy());
2224 CheckTrackAdapterSettingsEqualsFormat(result);
2225 }
2226 {
2227 constraint_factory_.Reset();
2228 constraint_factory_.basic().height.SetMax(4000);
2229 constraint_factory_.basic().width.SetMax(4000);
2230 auto result = SelectSettings();
2231 EXPECT_EQ(4000, result.Width());
2232 EXPECT_EQ(4000, result.Height());
2233 // Only specifying a maximum resolution allows resolution adjustment.
2234 EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
2235 result.ResolutionChangePolicy());
2236 EXPECT_EQ(1.0 / 4000, result.track_adapter_settings().min_aspect_ratio());
2237 EXPECT_EQ(4000.0, result.track_adapter_settings().max_aspect_ratio());
2238 CheckTrackAdapterSettingsEqualsFormat(result);
2239 }
2240 }
2241
2242 } // namespace media_stream_constraints_util_video_content_test
2243 } // namespace blink
2244