OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 #include <vector> | 6 #include <vector> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
11 #include "base/strings/string_number_conversions.h" | 11 #include "base/strings/string_number_conversions.h" |
12 #include "base/strings/utf_string_conversions.h" | 12 #include "base/strings/utf_string_conversions.h" |
| 13 #include "base/test/scoped_feature_list.h" |
13 #include "content/child/child_process.h" | 14 #include "content/child/child_process.h" |
| 15 #include "content/public/common/content_features.h" |
14 #include "content/renderer/media/media_stream_video_source.h" | 16 #include "content/renderer/media/media_stream_video_source.h" |
15 #include "content/renderer/media/media_stream_video_track.h" | 17 #include "content/renderer/media/media_stream_video_track.h" |
16 #include "content/renderer/media/mock_constraint_factory.h" | 18 #include "content/renderer/media/mock_constraint_factory.h" |
17 #include "content/renderer/media/mock_media_stream_video_sink.h" | 19 #include "content/renderer/media/mock_media_stream_video_sink.h" |
18 #include "content/renderer/media/mock_media_stream_video_source.h" | 20 #include "content/renderer/media/mock_media_stream_video_source.h" |
| 21 #include "content/renderer/media/video_track_adapter.h" |
19 #include "media/base/limits.h" | 22 #include "media/base/limits.h" |
20 #include "media/base/video_frame.h" | 23 #include "media/base/video_frame.h" |
21 #include "testing/gtest/include/gtest/gtest.h" | 24 #include "testing/gtest/include/gtest/gtest.h" |
22 #include "third_party/WebKit/public/web/WebHeap.h" | 25 #include "third_party/WebKit/public/web/WebHeap.h" |
23 | 26 |
24 using ::testing::_; | 27 using ::testing::_; |
25 using ::testing::DoAll; | 28 using ::testing::DoAll; |
26 using ::testing::SaveArg; | 29 using ::testing::SaveArg; |
27 | 30 |
28 namespace content { | 31 namespace content { |
29 | 32 |
30 ACTION_P(RunClosure, closure) { | 33 ACTION_P(RunClosure, closure) { |
31 closure.Run(); | 34 closure.Run(); |
32 } | 35 } |
33 | 36 |
34 class MediaStreamVideoSourceTest : public ::testing::Test { | 37 class MediaStreamVideoSourceTest : public ::testing::Test { |
35 public: | 38 public: |
36 MediaStreamVideoSourceTest() | 39 MediaStreamVideoSourceTest() |
37 : child_process_(new ChildProcess()), | 40 : child_process_(new ChildProcess()), |
38 number_of_successful_constraints_applied_(0), | 41 number_of_successful_constraints_applied_(0), |
39 number_of_failed_constraints_applied_(0), | 42 number_of_failed_constraints_applied_(0), |
40 result_(MEDIA_DEVICE_OK), | 43 result_(MEDIA_DEVICE_OK), |
41 result_name_(""), | 44 result_name_(""), |
42 mock_source_(new MockMediaStreamVideoSource(true)) { | 45 mock_source_(new MockMediaStreamVideoSource(true)), |
| 46 mock_source2_(new MockMediaStreamVideoSource( |
| 47 media::VideoCaptureFormat(gfx::Size(1280, 720), |
| 48 1000.0, |
| 49 media::PIXEL_FORMAT_I420), |
| 50 false)) { |
43 media::VideoCaptureFormats formats; | 51 media::VideoCaptureFormats formats; |
44 formats.push_back(media::VideoCaptureFormat( | 52 formats.push_back(media::VideoCaptureFormat( |
45 gfx::Size(1280, 720), 30, media::PIXEL_FORMAT_I420)); | 53 gfx::Size(1280, 720), 30, media::PIXEL_FORMAT_I420)); |
46 formats.push_back(media::VideoCaptureFormat( | 54 formats.push_back(media::VideoCaptureFormat( |
47 gfx::Size(640, 480), 30, media::PIXEL_FORMAT_I420)); | 55 gfx::Size(640, 480), 30, media::PIXEL_FORMAT_I420)); |
48 formats.push_back(media::VideoCaptureFormat( | 56 formats.push_back(media::VideoCaptureFormat( |
49 gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420)); | 57 gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420)); |
50 formats.push_back(media::VideoCaptureFormat( | 58 formats.push_back(media::VideoCaptureFormat( |
51 gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420)); | 59 gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420)); |
52 mock_source_->SetSupportedFormats(formats); | 60 mock_source_->SetSupportedFormats(formats); |
53 webkit_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), | 61 webkit_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), |
54 blink::WebMediaStreamSource::TypeVideo, | 62 blink::WebMediaStreamSource::TypeVideo, |
55 blink::WebString::fromASCII("dummy_source_name"), | 63 blink::WebString::fromASCII("dummy_source_name"), |
56 false /* remote */); | 64 false /* remote */); |
57 webkit_source_.setExtraData(mock_source_); | 65 webkit_source_.setExtraData(mock_source_); |
| 66 webkit_source2_.initialize(blink::WebString::fromASCII("dummy_source_id"), |
| 67 blink::WebMediaStreamSource::TypeVideo, |
| 68 blink::WebString::fromASCII("dummy_source_name"), |
| 69 false /* remote */); |
| 70 webkit_source2_.setExtraData(mock_source2_); |
58 } | 71 } |
59 | 72 |
60 void TearDown() override { | 73 void TearDown() override { |
61 webkit_source_.reset(); | 74 webkit_source_.reset(); |
| 75 webkit_source2_.reset(); |
62 blink::WebHeap::collectAllGarbageForTesting(); | 76 blink::WebHeap::collectAllGarbageForTesting(); |
63 } | 77 } |
64 | 78 |
65 protected: | 79 protected: |
66 // Create a track that's associated with |webkit_source_|. | 80 // Create a track that's associated with |webkit_source_|. |
67 blink::WebMediaStreamTrack CreateTrack( | 81 blink::WebMediaStreamTrack CreateTrack( |
68 const std::string& id, | 82 const std::string& id, |
69 const blink::WebMediaConstraints& constraints) { | 83 const blink::WebMediaConstraints& constraints) { |
70 bool enabled = true; | 84 bool enabled = true; |
71 return MediaStreamVideoTrack::CreateVideoTrack( | 85 return MediaStreamVideoTrack::CreateVideoTrack( |
72 mock_source_, constraints, | 86 mock_source_, constraints, |
73 base::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied, | 87 base::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied, |
74 base::Unretained(this)), | 88 base::Unretained(this)), |
75 enabled); | 89 enabled); |
76 } | 90 } |
77 | 91 |
| 92 blink::WebMediaStreamTrack CreateTrack(const std::string& id) { |
| 93 bool enabled = true; |
| 94 return MediaStreamVideoTrack::CreateVideoTrack( |
| 95 mock_source2_, |
| 96 base::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied, |
| 97 base::Unretained(this)), |
| 98 enabled); |
| 99 } |
| 100 |
| 101 blink::WebMediaStreamTrack CreateTrack( |
| 102 const std::string& id, |
| 103 const VideoTrackAdapterSettings& adapter_settings, |
| 104 const base::Optional<bool>& noise_reduction, |
| 105 bool is_screencast, |
| 106 double min_frame_rate) { |
| 107 bool enabled = true; |
| 108 return MediaStreamVideoTrack::CreateVideoTrack( |
| 109 mock_source2_, adapter_settings, noise_reduction, is_screencast, |
| 110 min_frame_rate, |
| 111 base::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied, |
| 112 base::Unretained(this)), |
| 113 enabled); |
| 114 } |
| 115 |
78 blink::WebMediaStreamTrack CreateTrackAndStartSource( | 116 blink::WebMediaStreamTrack CreateTrackAndStartSource( |
79 const blink::WebMediaConstraints& constraints, | 117 const blink::WebMediaConstraints& constraints, |
80 int expected_width, | 118 int expected_width, |
81 int expected_height, | 119 int expected_height, |
82 int expected_frame_rate) { | 120 int expected_frame_rate) { |
| 121 DCHECK(IsOldVideoConstraints()); |
83 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); | 122 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); |
84 | 123 |
85 mock_source_->CompleteGetSupportedFormats(); | 124 mock_source_->CompleteGetSupportedFormats(); |
86 const media::VideoCaptureFormat& format = mock_source()->start_format(); | 125 const media::VideoCaptureFormat& format = mock_source()->start_format(); |
87 EXPECT_EQ(expected_width, format.frame_size.width()); | 126 EXPECT_EQ(expected_width, format.frame_size.width()); |
88 EXPECT_EQ(expected_height, format.frame_size.height()); | 127 EXPECT_EQ(expected_height, format.frame_size.height()); |
89 EXPECT_EQ(expected_frame_rate, format.frame_rate); | 128 EXPECT_EQ(expected_frame_rate, format.frame_rate); |
90 | 129 |
91 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); | 130 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); |
92 mock_source_->StartMockedSource(); | 131 mock_source_->StartMockedSource(); |
93 // Once the source has started successfully we expect that the | 132 // Once the source has started successfully we expect that the |
94 // ConstraintsCallback in MediaStreamSource::AddTrack completes. | 133 // ConstraintsCallback in MediaStreamSource::AddTrack completes. |
95 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 134 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
96 return track; | 135 return track; |
97 } | 136 } |
98 | 137 |
| 138 blink::WebMediaStreamTrack CreateTrackAndStartSource(int width, |
| 139 int height, |
| 140 double frame_rate) { |
| 141 DCHECK(!IsOldVideoConstraints()); |
| 142 blink::WebMediaStreamTrack track = CreateTrack( |
| 143 "123", |
| 144 VideoTrackAdapterSettings(width, height, 0.0, HUGE_VAL, frame_rate), |
| 145 base::Optional<bool>(), false, 0.0); |
| 146 |
| 147 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); |
| 148 mock_source2_->StartMockedSource(); |
| 149 // Once the source has started successfully we expect that the |
| 150 // ConstraintsCallback in MediaStreamSource::AddTrack completes. |
| 151 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
| 152 return track; |
| 153 } |
| 154 |
99 int NumberOfSuccessConstraintsCallbacks() const { | 155 int NumberOfSuccessConstraintsCallbacks() const { |
100 return number_of_successful_constraints_applied_; | 156 return number_of_successful_constraints_applied_; |
101 } | 157 } |
102 | 158 |
103 int NumberOfFailedConstraintsCallbacks() const { | 159 int NumberOfFailedConstraintsCallbacks() const { |
104 return number_of_failed_constraints_applied_; | 160 return number_of_failed_constraints_applied_; |
105 } | 161 } |
106 | 162 |
107 content::MediaStreamRequestResult error_type() const { return result_; } | 163 content::MediaStreamRequestResult error_type() const { return result_; } |
108 blink::WebString error_name() const { return result_name_; } | 164 blink::WebString error_name() const { return result_name_; } |
109 | 165 |
110 MockMediaStreamVideoSource* mock_source() { return mock_source_; } | 166 MockMediaStreamVideoSource* mock_source() { |
| 167 return IsOldVideoConstraints() ? mock_source_ : mock_source2_; |
| 168 } |
| 169 |
| 170 const blink::WebMediaStreamSource& webkit_source() { |
| 171 return IsOldVideoConstraints() ? webkit_source_ : webkit_source2_; |
| 172 } |
111 | 173 |
112 // Test that the source crops/scales to the requested width and | 174 // Test that the source crops/scales to the requested width and |
113 // height even though the camera delivers a larger frame. | 175 // height even though the camera delivers a larger frame. |
114 void TestSourceCropFrame(int capture_width, | 176 void TestSourceCropFrame(int capture_width, |
115 int capture_height, | 177 int capture_height, |
116 const blink::WebMediaConstraints& constraints, | 178 const blink::WebMediaConstraints& constraints, |
117 int expected_width, | 179 int expected_width, |
118 int expected_height) { | 180 int expected_height) { |
| 181 DCHECK(IsOldVideoConstraints()); |
119 // Expect the source to start capture with the supported resolution. | 182 // Expect the source to start capture with the supported resolution. |
120 blink::WebMediaStreamTrack track = | 183 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( |
121 CreateTrackAndStartSource(constraints, capture_width, capture_height, | 184 constraints, capture_width, capture_height, 30); |
122 30); | |
123 | 185 |
124 MockMediaStreamVideoSink sink; | 186 MockMediaStreamVideoSink sink; |
125 sink.ConnectToTrack(track); | 187 sink.ConnectToTrack(track); |
126 DeliverVideoFrameAndWaitForRenderer(capture_width, capture_height, &sink); | 188 DeliverVideoFrameAndWaitForRenderer(capture_width, capture_height, &sink); |
| 189 EXPECT_EQ(1, sink.number_of_frames()); |
| 190 |
| 191 // Expect the delivered frame to be cropped. |
| 192 EXPECT_EQ(expected_height, sink.frame_size().height()); |
| 193 EXPECT_EQ(expected_width, sink.frame_size().width()); |
| 194 sink.DisconnectFromTrack(); |
| 195 } |
| 196 |
| 197 void TestSourceCropFrame(int capture_width, |
| 198 int capture_height, |
| 199 int expected_width, |
| 200 int expected_height) { |
| 201 DCHECK(!IsOldVideoConstraints()); |
| 202 // Configure the track to crop to the expected resolution. |
| 203 blink::WebMediaStreamTrack track = |
| 204 CreateTrackAndStartSource(expected_width, expected_height, 30.0); |
| 205 |
| 206 // Produce frames at the capture resolution. |
| 207 MockMediaStreamVideoSink sink; |
| 208 sink.ConnectToTrack(track); |
| 209 DeliverVideoFrameAndWaitForRenderer(capture_width, capture_height, &sink); |
127 EXPECT_EQ(1, sink.number_of_frames()); | 210 EXPECT_EQ(1, sink.number_of_frames()); |
128 | 211 |
129 // Expect the delivered frame to be cropped. | 212 // Expect the delivered frame to be cropped. |
130 EXPECT_EQ(expected_height, sink.frame_size().height()); | 213 EXPECT_EQ(expected_height, sink.frame_size().height()); |
131 EXPECT_EQ(expected_width, sink.frame_size().width()); | 214 EXPECT_EQ(expected_width, sink.frame_size().width()); |
132 sink.DisconnectFromTrack(); | 215 sink.DisconnectFromTrack(); |
133 } | 216 } |
134 | 217 |
135 void DeliverVideoFrameAndWaitForRenderer(int width, int height, | 218 void DeliverVideoFrameAndWaitForRenderer(int width, int height, |
136 MockMediaStreamVideoSink* sink) { | 219 MockMediaStreamVideoSink* sink) { |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
193 EXPECT_EQ(expected_height1, sink1.frame_size().height()); | 276 EXPECT_EQ(expected_height1, sink1.frame_size().height()); |
194 | 277 |
195 EXPECT_EQ(1, sink2.number_of_frames()); | 278 EXPECT_EQ(1, sink2.number_of_frames()); |
196 EXPECT_EQ(expected_width2, sink2.frame_size().width()); | 279 EXPECT_EQ(expected_width2, sink2.frame_size().width()); |
197 EXPECT_EQ(expected_height2, sink2.frame_size().height()); | 280 EXPECT_EQ(expected_height2, sink2.frame_size().height()); |
198 | 281 |
199 sink1.DisconnectFromTrack(); | 282 sink1.DisconnectFromTrack(); |
200 sink2.DisconnectFromTrack(); | 283 sink2.DisconnectFromTrack(); |
201 } | 284 } |
202 | 285 |
| 286 void TestTwoTracksWithDifferentSettings(int capture_width, |
| 287 int capture_height, |
| 288 int expected_width1, |
| 289 int expected_height1, |
| 290 int expected_width2, |
| 291 int expected_height2) { |
| 292 blink::WebMediaStreamTrack track1 = |
| 293 CreateTrackAndStartSource(expected_width1, expected_height1, |
| 294 MediaStreamVideoSource::kDefaultFrameRate); |
| 295 |
| 296 blink::WebMediaStreamTrack track2 = |
| 297 CreateTrack("dummy", |
| 298 VideoTrackAdapterSettings( |
| 299 expected_width2, expected_height2, 0.0, HUGE_VAL, |
| 300 MediaStreamVideoSource::kDefaultFrameRate), |
| 301 base::Optional<bool>(), false, 0.0); |
| 302 |
| 303 MockMediaStreamVideoSink sink1; |
| 304 sink1.ConnectToTrack(track1); |
| 305 EXPECT_EQ(0, sink1.number_of_frames()); |
| 306 |
| 307 MockMediaStreamVideoSink sink2; |
| 308 sink2.ConnectToTrack(track2); |
| 309 EXPECT_EQ(0, sink2.number_of_frames()); |
| 310 |
| 311 DeliverVideoFrameAndWaitForTwoRenderers(capture_width, capture_height, |
| 312 &sink1, &sink2); |
| 313 |
| 314 EXPECT_EQ(1, sink1.number_of_frames()); |
| 315 EXPECT_EQ(expected_width1, sink1.frame_size().width()); |
| 316 EXPECT_EQ(expected_height1, sink1.frame_size().height()); |
| 317 |
| 318 EXPECT_EQ(1, sink2.number_of_frames()); |
| 319 EXPECT_EQ(expected_width2, sink2.frame_size().width()); |
| 320 EXPECT_EQ(expected_height2, sink2.frame_size().height()); |
| 321 |
| 322 sink1.DisconnectFromTrack(); |
| 323 sink2.DisconnectFromTrack(); |
| 324 } |
203 void SetSourceSupportedFormats(const media::VideoCaptureFormats& formats) { | 325 void SetSourceSupportedFormats(const media::VideoCaptureFormats& formats) { |
204 mock_source_->SetSupportedFormats(formats); | 326 mock_source_->SetSupportedFormats(formats); |
205 } | 327 } |
206 | 328 |
207 void ReleaseTrackAndSourceOnAddTrackCallback( | 329 void ReleaseTrackAndSourceOnAddTrackCallback( |
208 const blink::WebMediaStreamTrack& track_to_release) { | 330 const blink::WebMediaStreamTrack& track_to_release) { |
209 track_to_release_ = track_to_release; | 331 track_to_release_ = track_to_release; |
210 } | 332 } |
211 | 333 |
212 private: | 334 private: |
213 void OnConstraintsApplied(MediaStreamSource* source, | 335 void OnConstraintsApplied(MediaStreamSource* source, |
214 MediaStreamRequestResult result, | 336 MediaStreamRequestResult result, |
215 const blink::WebString& result_name) { | 337 const blink::WebString& result_name) { |
216 ASSERT_EQ(source, webkit_source_.getExtraData()); | 338 ASSERT_EQ(source, webkit_source().getExtraData()); |
217 | 339 |
218 if (result == MEDIA_DEVICE_OK) { | 340 if (result == MEDIA_DEVICE_OK) { |
219 ++number_of_successful_constraints_applied_; | 341 ++number_of_successful_constraints_applied_; |
220 } else { | 342 } else { |
221 result_ = result; | 343 result_ = result; |
222 result_name_ = result_name; | 344 result_name_ = result_name; |
223 ++number_of_failed_constraints_applied_; | 345 ++number_of_failed_constraints_applied_; |
224 } | 346 } |
225 | 347 |
226 if (!track_to_release_.isNull()) { | 348 if (!track_to_release_.isNull()) { |
227 mock_source_ = NULL; | 349 mock_source_ = nullptr; |
228 webkit_source_.reset(); | 350 webkit_source_.reset(); |
| 351 mock_source2_ = nullptr; |
| 352 webkit_source2_.reset(); |
229 track_to_release_.reset(); | 353 track_to_release_.reset(); |
230 } | 354 } |
231 } | 355 } |
232 const base::MessageLoopForUI message_loop_; | 356 const base::MessageLoopForUI message_loop_; |
233 const std::unique_ptr<ChildProcess> child_process_; | 357 const std::unique_ptr<ChildProcess> child_process_; |
234 blink::WebMediaStreamTrack track_to_release_; | 358 blink::WebMediaStreamTrack track_to_release_; |
235 int number_of_successful_constraints_applied_; | 359 int number_of_successful_constraints_applied_; |
236 int number_of_failed_constraints_applied_; | 360 int number_of_failed_constraints_applied_; |
237 content::MediaStreamRequestResult result_; | 361 content::MediaStreamRequestResult result_; |
238 blink::WebString result_name_; | 362 blink::WebString result_name_; |
239 blink::WebMediaStreamSource webkit_source_; | 363 blink::WebMediaStreamSource webkit_source_; |
240 // |mock_source_| is owned by |webkit_source_|. | 364 // |mock_source_| is owned by |webkit_source_|. |
241 MockMediaStreamVideoSource* mock_source_; | 365 MockMediaStreamVideoSource* mock_source_; |
| 366 blink::WebMediaStreamSource webkit_source2_; |
| 367 // |mock_source2_| is owned by |webkit_source2_|. |
| 368 MockMediaStreamVideoSource* mock_source2_; |
242 }; | 369 }; |
243 | 370 |
244 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartSource) { | 371 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 372 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartSourceOldConstraints) { |
| 373 base::test::ScopedFeatureList scoped_feature_list; |
| 374 scoped_feature_list.InitAndEnableFeature( |
| 375 features::kMediaStreamOldVideoConstraints); |
245 blink::WebMediaConstraints constraints; | 376 blink::WebMediaConstraints constraints; |
246 constraints.initialize(); | 377 constraints.initialize(); |
247 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); | 378 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); |
248 mock_source()->CompleteGetSupportedFormats(); | 379 mock_source()->CompleteGetSupportedFormats(); |
249 mock_source()->StartMockedSource(); | 380 mock_source()->StartMockedSource(); |
250 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 381 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
251 } | 382 } |
252 | 383 |
253 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeSourceStarts) { | 384 TEST_F(MediaStreamVideoSourceTest, AddTrackAndStartSource) { |
| 385 base::test::ScopedFeatureList scoped_feature_list; |
| 386 scoped_feature_list.InitAndDisableFeature( |
| 387 features::kMediaStreamOldVideoConstraints); |
| 388 blink::WebMediaStreamTrack track = CreateTrack("123"); |
| 389 mock_source()->StartMockedSource(); |
| 390 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
| 391 } |
| 392 |
| 393 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 394 TEST_F(MediaStreamVideoSourceTest, |
| 395 AddTwoTracksBeforeSourceStartsOldConstraints) { |
| 396 base::test::ScopedFeatureList scoped_feature_list; |
| 397 scoped_feature_list.InitAndEnableFeature( |
| 398 features::kMediaStreamOldVideoConstraints); |
254 blink::WebMediaConstraints constraints; | 399 blink::WebMediaConstraints constraints; |
255 constraints.initialize(); | 400 constraints.initialize(); |
256 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); | 401 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); |
257 mock_source()->CompleteGetSupportedFormats(); | 402 mock_source()->CompleteGetSupportedFormats(); |
258 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); | 403 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); |
259 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); | 404 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); |
260 mock_source()->StartMockedSource(); | 405 mock_source()->StartMockedSource(); |
261 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); | 406 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
262 } | 407 } |
263 | 408 |
264 TEST_F(MediaStreamVideoSourceTest, AddTrackAfterSourceStarts) { | 409 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeSourceStarts) { |
| 410 base::test::ScopedFeatureList scoped_feature_list; |
| 411 scoped_feature_list.InitAndDisableFeature( |
| 412 features::kMediaStreamOldVideoConstraints); |
| 413 blink::WebMediaStreamTrack track1 = CreateTrack("123"); |
| 414 blink::WebMediaStreamTrack track2 = CreateTrack("123"); |
| 415 EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks()); |
| 416 mock_source()->StartMockedSource(); |
| 417 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
| 418 } |
| 419 |
| 420 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 421 TEST_F(MediaStreamVideoSourceTest, AddTrackAfterSourceStartsOldConstraints) { |
| 422 base::test::ScopedFeatureList scoped_feature_list; |
| 423 scoped_feature_list.InitAndEnableFeature( |
| 424 features::kMediaStreamOldVideoConstraints); |
265 blink::WebMediaConstraints constraints; | 425 blink::WebMediaConstraints constraints; |
266 constraints.initialize(); | 426 constraints.initialize(); |
267 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); | 427 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); |
268 mock_source()->CompleteGetSupportedFormats(); | 428 mock_source()->CompleteGetSupportedFormats(); |
269 mock_source()->StartMockedSource(); | 429 mock_source()->StartMockedSource(); |
270 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 430 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
271 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); | 431 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); |
272 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); | 432 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
273 } | 433 } |
274 | 434 |
275 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartSource) { | 435 TEST_F(MediaStreamVideoSourceTest, AddTrackAfterSourceStarts) { |
| 436 base::test::ScopedFeatureList scoped_feature_list; |
| 437 scoped_feature_list.InitAndDisableFeature( |
| 438 features::kMediaStreamOldVideoConstraints); |
| 439 blink::WebMediaStreamTrack track1 = CreateTrack("123"); |
| 440 mock_source()->StartMockedSource(); |
| 441 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
| 442 blink::WebMediaStreamTrack track2 = CreateTrack("123"); |
| 443 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
| 444 } |
| 445 |
| 446 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 447 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartSourceOldConstraints) { |
| 448 base::test::ScopedFeatureList scoped_feature_list; |
| 449 scoped_feature_list.InitAndEnableFeature( |
| 450 features::kMediaStreamOldVideoConstraints); |
276 blink::WebMediaConstraints constraints; | 451 blink::WebMediaConstraints constraints; |
277 constraints.initialize(); | 452 constraints.initialize(); |
278 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); | 453 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); |
279 mock_source()->CompleteGetSupportedFormats(); | 454 mock_source()->CompleteGetSupportedFormats(); |
280 mock_source()->FailToStartMockedSource(); | 455 mock_source()->FailToStartMockedSource(); |
281 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 456 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
282 } | 457 } |
283 | 458 |
284 TEST_F(MediaStreamVideoSourceTest, AddTwoTracksBeforeGetSupportedFormats) { | 459 TEST_F(MediaStreamVideoSourceTest, AddTrackAndFailToStartSource) { |
| 460 base::test::ScopedFeatureList scoped_feature_list; |
| 461 scoped_feature_list.InitAndDisableFeature( |
| 462 features::kMediaStreamOldVideoConstraints); |
| 463 blink::WebMediaStreamTrack track = CreateTrack("123"); |
| 464 mock_source()->FailToStartMockedSource(); |
| 465 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
| 466 } |
| 467 |
| 468 // Does not apply with spec-compliant constraints. |
| 469 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 470 TEST_F(MediaStreamVideoSourceTest, |
| 471 AddTwoTracksBeforeGetSupportedFormatsOldConstraints) { |
| 472 base::test::ScopedFeatureList scoped_feature_list; |
| 473 scoped_feature_list.InitAndEnableFeature( |
| 474 features::kMediaStreamOldVideoConstraints); |
285 blink::WebMediaConstraints constraints; | 475 blink::WebMediaConstraints constraints; |
286 constraints.initialize(); | 476 constraints.initialize(); |
287 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); | 477 blink::WebMediaStreamTrack track1 = CreateTrack("123", constraints); |
288 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); | 478 blink::WebMediaStreamTrack track2 = CreateTrack("123", constraints); |
289 mock_source()->CompleteGetSupportedFormats(); | 479 mock_source()->CompleteGetSupportedFormats(); |
290 mock_source()->StartMockedSource(); | 480 mock_source()->StartMockedSource(); |
291 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); | 481 EXPECT_EQ(2, NumberOfSuccessConstraintsCallbacks()); |
292 } | 482 } |
293 | 483 |
294 // Test that the capture output is CIF if we set max constraints to CIF. | 484 // Test that the capture output is CIF if we set max constraints to CIF. |
295 // and the capture device support CIF. | 485 // and the capture device support CIF. |
296 TEST_F(MediaStreamVideoSourceTest, MandatoryConstraintCif5Fps) { | 486 // Does not apply with spec-compliant constraints. |
| 487 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 488 TEST_F(MediaStreamVideoSourceTest, MandatoryConstraintCif5FpsOldConstraints) { |
| 489 base::test::ScopedFeatureList scoped_feature_list; |
| 490 scoped_feature_list.InitAndEnableFeature( |
| 491 features::kMediaStreamOldVideoConstraints); |
297 MockConstraintFactory factory; | 492 MockConstraintFactory factory; |
298 factory.basic().width.setMax(352); | 493 factory.basic().width.setMax(352); |
299 factory.basic().height.setMax(288); | 494 factory.basic().height.setMax(288); |
300 factory.basic().frameRate.setMax(5.0); | 495 factory.basic().frameRate.setMax(5.0); |
301 | 496 |
302 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 352, 288, 5); | 497 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 352, 288, 5); |
303 } | 498 } |
304 | 499 |
305 // Test that the capture output is 720P if the camera support it and the | 500 // Test that the capture output is 720P if the camera support it and the |
306 // optional constraint is set to 720P. | 501 // optional constraint is set to 720P. |
307 TEST_F(MediaStreamVideoSourceTest, MandatoryMinVgaOptional720P) { | 502 // Does not apply with spec-compliant constraints. |
| 503 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 504 TEST_F(MediaStreamVideoSourceTest, MandatoryMinVgaOptional720POldConstraints) { |
| 505 base::test::ScopedFeatureList scoped_feature_list; |
| 506 scoped_feature_list.InitAndEnableFeature( |
| 507 features::kMediaStreamOldVideoConstraints); |
308 MockConstraintFactory factory; | 508 MockConstraintFactory factory; |
309 factory.basic().width.setMin(640); | 509 factory.basic().width.setMin(640); |
310 factory.basic().height.setMin(480); | 510 factory.basic().height.setMin(480); |
311 factory.AddAdvanced().width.setMin(1280); | 511 factory.AddAdvanced().width.setMin(1280); |
312 factory.AddAdvanced().aspectRatio.setMin(1280.0 / 720); | 512 factory.AddAdvanced().aspectRatio.setMin(1280.0 / 720); |
313 | 513 |
314 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); | 514 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); |
315 } | 515 } |
316 | 516 |
317 // Test that the capture output is 720P if the camera supports it and the | 517 // Test that the capture output is 720P if the camera supports it and the |
318 // mandatory constraint is exactly width 1280. | 518 // mandatory constraint is exactly width 1280. |
319 TEST_F(MediaStreamVideoSourceTest, MandatoryExact720P) { | 519 // Does not apply with spec-compliant constraints. |
| 520 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 521 TEST_F(MediaStreamVideoSourceTest, MandatoryExact720POldConstraints) { |
| 522 base::test::ScopedFeatureList scoped_feature_list; |
| 523 scoped_feature_list.InitAndEnableFeature( |
| 524 features::kMediaStreamOldVideoConstraints); |
320 MockConstraintFactory factory; | 525 MockConstraintFactory factory; |
321 factory.basic().width.setExact(1280); | 526 factory.basic().width.setExact(1280); |
322 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); | 527 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); |
323 } | 528 } |
324 | 529 |
325 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint | 530 // Test that the capture output have aspect ratio 4:3 if a mandatory constraint |
326 // require it even if an optional constraint request a higher resolution | 531 // require it even if an optional constraint request a higher resolution |
327 // that don't have this aspect ratio. | 532 // that don't have this aspect ratio. |
328 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3) { | 533 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 534 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3OldConstraints) { |
| 535 base::test::ScopedFeatureList scoped_feature_list; |
| 536 scoped_feature_list.InitAndEnableFeature( |
| 537 features::kMediaStreamOldVideoConstraints); |
329 MockConstraintFactory factory; | 538 MockConstraintFactory factory; |
330 factory.basic().width.setMin(640); | 539 factory.basic().width.setMin(640); |
331 factory.basic().height.setMin(480); | 540 factory.basic().height.setMin(480); |
332 factory.basic().aspectRatio.setMax(640.0 / 480); | 541 factory.basic().aspectRatio.setMax(640.0 / 480); |
333 factory.AddAdvanced().width.setMin(1280); | 542 factory.AddAdvanced().width.setMin(1280); |
334 | 543 |
335 TestSourceCropFrame(1280, 720, | 544 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 960, 720); |
336 factory.CreateWebMediaConstraints(), 960, 720); | 545 } |
| 546 |
| 547 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio4To3) { |
| 548 base::test::ScopedFeatureList scoped_feature_list; |
| 549 scoped_feature_list.InitAndDisableFeature( |
| 550 features::kMediaStreamOldVideoConstraints); |
| 551 TestSourceCropFrame(1280, 720, 960, 720); |
337 } | 552 } |
338 | 553 |
339 // Test that AddTrack succeeds if the mandatory min aspect ratio it set to 2. | 554 // Test that AddTrack succeeds if the mandatory min aspect ratio it set to 2. |
340 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2) { | 555 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2OldConstraints) { |
| 556 base::test::ScopedFeatureList scoped_feature_list; |
| 557 scoped_feature_list.InitAndEnableFeature( |
| 558 features::kMediaStreamOldVideoConstraints); |
341 MockConstraintFactory factory; | 559 MockConstraintFactory factory; |
342 factory.basic().aspectRatio.setMin(2.0); | 560 factory.basic().aspectRatio.setMin(2.0); |
343 | 561 |
344 TestSourceCropFrame(MediaStreamVideoSource::kDefaultWidth, | 562 TestSourceCropFrame(MediaStreamVideoSource::kDefaultWidth, |
345 MediaStreamVideoSource::kDefaultHeight, | 563 MediaStreamVideoSource::kDefaultHeight, |
346 factory.CreateWebMediaConstraints(), 640, 320); | 564 factory.CreateWebMediaConstraints(), 640, 320); |
347 } | 565 } |
348 | 566 |
349 TEST_F(MediaStreamVideoSourceTest, MinAspectRatioLargerThanMaxAspectRatio) { | 567 TEST_F(MediaStreamVideoSourceTest, MandatoryAspectRatio2) { |
| 568 base::test::ScopedFeatureList scoped_feature_list; |
| 569 scoped_feature_list.InitAndDisableFeature( |
| 570 features::kMediaStreamOldVideoConstraints); |
| 571 TestSourceCropFrame(1280, 720, 960, 720); |
| 572 } |
| 573 |
| 574 // Does not apply with spec-compliant constraints. |
| 575 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 576 TEST_F(MediaStreamVideoSourceTest, |
| 577 MinAspectRatioLargerThanMaxAspectRatioOldConstraints) { |
| 578 base::test::ScopedFeatureList scoped_feature_list; |
| 579 scoped_feature_list.InitAndEnableFeature( |
| 580 features::kMediaStreamOldVideoConstraints); |
350 MockConstraintFactory factory; | 581 MockConstraintFactory factory; |
351 factory.basic().aspectRatio.setMin(2.0); | 582 factory.basic().aspectRatio.setMin(2.0); |
352 factory.basic().aspectRatio.setMax(1.0); | 583 factory.basic().aspectRatio.setMax(1.0); |
353 blink::WebMediaStreamTrack track = CreateTrack( | 584 blink::WebMediaStreamTrack track = |
354 "123", factory.CreateWebMediaConstraints()); | 585 CreateTrack("123", factory.CreateWebMediaConstraints()); |
355 mock_source()->CompleteGetSupportedFormats(); | 586 mock_source()->CompleteGetSupportedFormats(); |
356 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 587 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
357 } | 588 } |
358 | 589 |
359 TEST_F(MediaStreamVideoSourceTest, MinWidthLargerThanMaxWidth) { | 590 // Does not apply with spec-compliant constraints. |
| 591 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 592 TEST_F(MediaStreamVideoSourceTest, MinWidthLargerThanMaxWidthOldConstraints) { |
| 593 base::test::ScopedFeatureList scoped_feature_list; |
| 594 scoped_feature_list.InitAndEnableFeature( |
| 595 features::kMediaStreamOldVideoConstraints); |
360 MockConstraintFactory factory; | 596 MockConstraintFactory factory; |
361 factory.basic().width.setMin(640); | 597 factory.basic().width.setMin(640); |
362 factory.basic().width.setMax(320); | 598 factory.basic().width.setMax(320); |
363 blink::WebMediaStreamTrack track = CreateTrack( | 599 blink::WebMediaStreamTrack track = |
364 "123", factory.CreateWebMediaConstraints()); | 600 CreateTrack("123", factory.CreateWebMediaConstraints()); |
365 mock_source()->CompleteGetSupportedFormats(); | 601 mock_source()->CompleteGetSupportedFormats(); |
366 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 602 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
367 } | 603 } |
368 | 604 |
369 TEST_F(MediaStreamVideoSourceTest, MinHeightLargerThanMaxHeight) { | 605 // Does not apply with spec-compliant constraints. |
| 606 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 607 TEST_F(MediaStreamVideoSourceTest, MinHeightLargerThanMaxHeightOldConstraints) { |
| 608 base::test::ScopedFeatureList scoped_feature_list; |
| 609 scoped_feature_list.InitAndEnableFeature( |
| 610 features::kMediaStreamOldVideoConstraints); |
370 MockConstraintFactory factory; | 611 MockConstraintFactory factory; |
371 factory.basic().height.setMin(480); | 612 factory.basic().height.setMin(480); |
372 factory.basic().height.setMax(360); | 613 factory.basic().height.setMax(360); |
373 | 614 |
374 blink::WebMediaStreamTrack track = CreateTrack( | 615 blink::WebMediaStreamTrack track = |
375 "123", factory.CreateWebMediaConstraints()); | 616 CreateTrack("123", factory.CreateWebMediaConstraints()); |
376 mock_source()->CompleteGetSupportedFormats(); | 617 mock_source()->CompleteGetSupportedFormats(); |
377 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 618 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
378 } | 619 } |
379 | 620 |
380 TEST_F(MediaStreamVideoSourceTest, MinFrameRateLargerThanMaxFrameRate) { | 621 // Does not apply with spec-compliant constraints. |
| 622 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 623 TEST_F(MediaStreamVideoSourceTest, |
| 624 MinFrameRateLargerThanMaxFrameRateOldConstraints) { |
| 625 base::test::ScopedFeatureList scoped_feature_list; |
| 626 scoped_feature_list.InitAndEnableFeature( |
| 627 features::kMediaStreamOldVideoConstraints); |
381 MockConstraintFactory factory; | 628 MockConstraintFactory factory; |
382 factory.basic().frameRate.setMin(25); | 629 factory.basic().frameRate.setMin(25); |
383 factory.basic().frameRate.setMax(15); | 630 factory.basic().frameRate.setMax(15); |
384 blink::WebMediaStreamTrack track = | 631 blink::WebMediaStreamTrack track = |
385 CreateTrack("123", factory.CreateWebMediaConstraints()); | 632 CreateTrack("123", factory.CreateWebMediaConstraints()); |
386 mock_source()->CompleteGetSupportedFormats(); | 633 mock_source()->CompleteGetSupportedFormats(); |
387 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 634 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
388 } | 635 } |
389 | 636 |
390 TEST_F(MediaStreamVideoSourceTest, ExactWidthNotSupported) { | 637 // Does not apply with spec-compliant constraints. |
| 638 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 639 TEST_F(MediaStreamVideoSourceTest, ExactWidthNotSupportedOldConstraints) { |
| 640 base::test::ScopedFeatureList scoped_feature_list; |
| 641 scoped_feature_list.InitAndEnableFeature( |
| 642 features::kMediaStreamOldVideoConstraints); |
391 MockConstraintFactory factory; | 643 MockConstraintFactory factory; |
392 factory.basic().width.setExact(12000); | 644 factory.basic().width.setExact(12000); |
393 blink::WebMediaStreamTrack track = | 645 blink::WebMediaStreamTrack track = |
394 CreateTrack("123", factory.CreateWebMediaConstraints()); | 646 CreateTrack("123", factory.CreateWebMediaConstraints()); |
395 mock_source()->CompleteGetSupportedFormats(); | 647 mock_source()->CompleteGetSupportedFormats(); |
396 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 648 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
397 } | 649 } |
398 | 650 |
399 TEST_F(MediaStreamVideoSourceTest, MinWidthNotSupported) { | 651 // Does not apply with spec-compliant constraints. |
| 652 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 653 TEST_F(MediaStreamVideoSourceTest, MinWidthNotSupportedOldConstraints) { |
| 654 base::test::ScopedFeatureList scoped_feature_list; |
| 655 scoped_feature_list.InitAndEnableFeature( |
| 656 features::kMediaStreamOldVideoConstraints); |
400 MockConstraintFactory factory; | 657 MockConstraintFactory factory; |
401 factory.basic().width.setMin(12000); | 658 factory.basic().width.setMin(12000); |
402 blink::WebMediaStreamTrack track = | 659 blink::WebMediaStreamTrack track = |
403 CreateTrack("123", factory.CreateWebMediaConstraints()); | 660 CreateTrack("123", factory.CreateWebMediaConstraints()); |
404 mock_source()->CompleteGetSupportedFormats(); | 661 mock_source()->CompleteGetSupportedFormats(); |
405 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 662 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
406 } | 663 } |
407 | 664 |
408 // Test that its safe to release the last reference of a blink track and the | 665 // Test that its safe to release the last reference of a blink track and the |
409 // source during the callback if adding a track succeeds. | 666 // source during the callback if adding a track succeeds. |
| 667 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 668 TEST_F(MediaStreamVideoSourceTest, |
| 669 ReleaseTrackAndSourceOnSuccessCallBackOldConstraints) { |
| 670 base::test::ScopedFeatureList scoped_feature_list; |
| 671 scoped_feature_list.InitAndEnableFeature( |
| 672 features::kMediaStreamOldVideoConstraints); |
| 673 MockConstraintFactory factory; |
| 674 blink::WebMediaStreamTrack track = |
| 675 CreateTrack("123", factory.CreateWebMediaConstraints()); |
| 676 ReleaseTrackAndSourceOnAddTrackCallback(track); |
| 677 mock_source()->CompleteGetSupportedFormats(); |
| 678 mock_source()->StartMockedSource(); |
| 679 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
| 680 } |
| 681 |
410 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnSuccessCallBack) { | 682 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnSuccessCallBack) { |
411 MockConstraintFactory factory; | 683 base::test::ScopedFeatureList scoped_feature_list; |
412 { | 684 scoped_feature_list.InitAndDisableFeature( |
413 blink::WebMediaStreamTrack track = | 685 features::kMediaStreamOldVideoConstraints); |
414 CreateTrack("123", factory.CreateWebMediaConstraints()); | 686 blink::WebMediaStreamTrack track = CreateTrack("123"); |
415 ReleaseTrackAndSourceOnAddTrackCallback(track); | 687 ReleaseTrackAndSourceOnAddTrackCallback(track); |
416 } | |
417 mock_source()->CompleteGetSupportedFormats(); | |
418 mock_source()->StartMockedSource(); | 688 mock_source()->StartMockedSource(); |
419 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 689 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
420 } | 690 } |
421 | 691 |
422 // Test that its safe to release the last reference of a blink track and the | 692 // Test that its safe to release the last reference of a blink track and the |
423 // source during the callback if adding a track fails. | 693 // source during the callback if adding a track fails. |
424 TEST_F(MediaStreamVideoSourceTest, ReleaseTrackAndSourceOnFailureCallBack) { | 694 // Does not apply with spec-compliant constraints. |
| 695 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 696 TEST_F(MediaStreamVideoSourceTest, |
| 697 ReleaseTrackAndSourceOnFailureCallBackOldConstraints) { |
| 698 base::test::ScopedFeatureList scoped_feature_list; |
| 699 scoped_feature_list.InitAndEnableFeature( |
| 700 features::kMediaStreamOldVideoConstraints); |
425 MockConstraintFactory factory; | 701 MockConstraintFactory factory; |
426 factory.basic().width.setMin(99999); | 702 factory.basic().width.setMin(99999); |
427 { | 703 { |
428 blink::WebMediaStreamTrack track = | 704 blink::WebMediaStreamTrack track = |
429 CreateTrack("123", factory.CreateWebMediaConstraints()); | 705 CreateTrack("123", factory.CreateWebMediaConstraints()); |
430 ReleaseTrackAndSourceOnAddTrackCallback(track); | 706 ReleaseTrackAndSourceOnAddTrackCallback(track); |
431 } | 707 } |
432 mock_source()->CompleteGetSupportedFormats(); | 708 mock_source()->CompleteGetSupportedFormats(); |
433 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 709 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
434 } | 710 } |
435 | 711 |
436 // Test that the source ignores an optional aspect ratio that is higher than | 712 // Test that the source ignores an optional aspect ratio that is higher than |
437 // supported. | 713 // supported. |
438 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHigh) { | 714 // Does not apply with spec-compliant constraints. |
| 715 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 716 TEST_F(MediaStreamVideoSourceTest, OptionalAspectRatioTooHighOldConstraints) { |
| 717 base::test::ScopedFeatureList scoped_feature_list; |
| 718 scoped_feature_list.InitAndEnableFeature( |
| 719 features::kMediaStreamOldVideoConstraints); |
439 MockConstraintFactory factory; | 720 MockConstraintFactory factory; |
440 factory.AddAdvanced().aspectRatio.setMin(2.0); | 721 factory.AddAdvanced().aspectRatio.setMin(2.0); |
441 blink::WebMediaStreamTrack track = CreateTrack( | 722 blink::WebMediaStreamTrack track = |
442 "123", factory.CreateWebMediaConstraints()); | 723 CreateTrack("123", factory.CreateWebMediaConstraints()); |
443 mock_source()->CompleteGetSupportedFormats(); | 724 mock_source()->CompleteGetSupportedFormats(); |
444 | 725 |
445 const media::VideoCaptureFormat& format = mock_source()->start_format(); | 726 const media::VideoCaptureFormat& format = mock_source()->start_format(); |
446 const double aspect_ratio = static_cast<double>(format.frame_size.width()) / | 727 const double aspect_ratio = static_cast<double>(format.frame_size.width()) / |
447 format.frame_size.height(); | 728 format.frame_size.height(); |
448 EXPECT_LT(aspect_ratio, 2); | 729 EXPECT_LT(aspect_ratio, 2); |
449 } | 730 } |
450 | 731 |
451 // Test that the source starts video with the default resolution if the | 732 // Test that the source starts video with the default resolution if the |
452 // that is the only supported. | 733 // that is the only supported. |
453 TEST_F(MediaStreamVideoSourceTest, DefaultCapability) { | 734 // Does not apply with spec-compliant constraints. |
| 735 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 736 TEST_F(MediaStreamVideoSourceTest, DefaultCapabilityOldConstraints) { |
| 737 base::test::ScopedFeatureList scoped_feature_list; |
| 738 scoped_feature_list.InitAndEnableFeature( |
| 739 features::kMediaStreamOldVideoConstraints); |
454 media::VideoCaptureFormats formats; | 740 media::VideoCaptureFormats formats; |
455 formats.push_back(media::VideoCaptureFormat( | 741 formats.push_back(media::VideoCaptureFormat( |
456 gfx::Size(MediaStreamVideoSource::kDefaultWidth, | 742 gfx::Size(MediaStreamVideoSource::kDefaultWidth, |
457 MediaStreamVideoSource::kDefaultHeight), | 743 MediaStreamVideoSource::kDefaultHeight), |
458 MediaStreamVideoSource::kDefaultFrameRate, | 744 MediaStreamVideoSource::kDefaultFrameRate, media::PIXEL_FORMAT_I420)); |
459 media::PIXEL_FORMAT_I420)); | |
460 mock_source()->SetSupportedFormats(formats); | 745 mock_source()->SetSupportedFormats(formats); |
461 | 746 |
462 blink::WebMediaConstraints constraints; | 747 blink::WebMediaConstraints constraints; |
463 constraints.initialize(); | 748 constraints.initialize(); |
464 CreateTrackAndStartSource(constraints, | 749 CreateTrackAndStartSource(constraints, MediaStreamVideoSource::kDefaultWidth, |
465 MediaStreamVideoSource::kDefaultWidth, | 750 MediaStreamVideoSource::kDefaultHeight, 30); |
466 MediaStreamVideoSource::kDefaultHeight, | |
467 30); | |
468 } | 751 } |
469 | 752 |
470 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraint) { | 753 // Does not apply with spec-compliant constraints. |
| 754 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 755 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryConstraintOldConstraints) { |
| 756 base::test::ScopedFeatureList scoped_feature_list; |
| 757 scoped_feature_list.InitAndEnableFeature( |
| 758 features::kMediaStreamOldVideoConstraints); |
471 MockConstraintFactory factory; | 759 MockConstraintFactory factory; |
472 // Use a constraint that is only known for audio. | 760 // Use a constraint that is only known for audio. |
473 factory.basic().echoCancellation.setExact(true); | 761 factory.basic().echoCancellation.setExact(true); |
474 blink::WebMediaStreamTrack track = CreateTrack( | 762 blink::WebMediaStreamTrack track = |
475 "123", factory.CreateWebMediaConstraints()); | 763 CreateTrack("123", factory.CreateWebMediaConstraints()); |
476 mock_source()->CompleteGetSupportedFormats(); | 764 mock_source()->CompleteGetSupportedFormats(); |
477 EXPECT_EQ(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED, error_type()); | 765 EXPECT_EQ(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED, error_type()); |
478 EXPECT_EQ("echoCancellation", error_name()); | 766 EXPECT_EQ("echoCancellation", error_name()); |
479 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 767 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
480 } | 768 } |
481 | 769 |
482 // Test that the source ignores an unknown optional constraint. | 770 // Test that the source ignores an unknown optional constraint. |
483 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraint) { | 771 // Does not apply with spec-compliant constraints. |
| 772 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 773 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalConstraintOldConstraints) { |
| 774 base::test::ScopedFeatureList scoped_feature_list; |
| 775 scoped_feature_list.InitAndEnableFeature( |
| 776 features::kMediaStreamOldVideoConstraints); |
484 MockConstraintFactory factory; | 777 MockConstraintFactory factory; |
485 factory.AddAdvanced().echoCancellation.setExact(true); | 778 factory.AddAdvanced().echoCancellation.setExact(true); |
486 | 779 |
487 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), | 780 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), |
488 MediaStreamVideoSource::kDefaultWidth, | 781 MediaStreamVideoSource::kDefaultWidth, |
489 MediaStreamVideoSource::kDefaultHeight, | 782 MediaStreamVideoSource::kDefaultHeight, 30); |
490 30); | |
491 } | 783 } |
492 | 784 |
493 // Tests that the source starts video with the max width and height set by | 785 // Tests that the source starts video with the max width and height set by |
494 // constraints for screencast. | 786 // constraints for screencast. |
495 TEST_F(MediaStreamVideoSourceTest, ScreencastResolutionWithConstraint) { | 787 // Does not apply with spec-compliant constraints. |
| 788 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 789 TEST_F(MediaStreamVideoSourceTest, |
| 790 ScreencastResolutionWithConstraintOldConstraints) { |
| 791 base::test::ScopedFeatureList scoped_feature_list; |
| 792 scoped_feature_list.InitAndEnableFeature( |
| 793 features::kMediaStreamOldVideoConstraints); |
496 media::VideoCaptureFormats formats; | 794 media::VideoCaptureFormats formats; |
497 formats.push_back(media::VideoCaptureFormat( | 795 formats.push_back(media::VideoCaptureFormat(gfx::Size(480, 270), 30, |
498 gfx::Size(480, 270), 30, media::PIXEL_FORMAT_I420)); | 796 media::PIXEL_FORMAT_I420)); |
499 mock_source()->SetSupportedFormats(formats); | 797 mock_source()->SetSupportedFormats(formats); |
500 MockConstraintFactory factory; | 798 MockConstraintFactory factory; |
501 factory.basic().width.setMax(480); | 799 factory.basic().width.setMax(480); |
502 factory.basic().height.setMax(270); | 800 factory.basic().height.setMax(270); |
503 | 801 |
504 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( | 802 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( |
505 factory.CreateWebMediaConstraints(), 480, 270, 30); | 803 factory.CreateWebMediaConstraints(), 480, 270, 30); |
506 EXPECT_EQ(480, mock_source()->max_requested_height()); | 804 EXPECT_EQ(480, mock_source()->max_requested_height()); |
507 EXPECT_EQ(270, mock_source()->max_requested_width()); | 805 EXPECT_EQ(270, mock_source()->max_requested_width()); |
508 } | 806 } |
509 | 807 |
510 // Test that optional constraints are applied in order. | 808 // Test that optional constraints are applied in order. |
511 TEST_F(MediaStreamVideoSourceTest, OptionalConstraints) { | 809 // Does not apply with spec-compliant constraints. |
| 810 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 811 TEST_F(MediaStreamVideoSourceTest, OptionalConstraintsOldConstraints) { |
| 812 base::test::ScopedFeatureList scoped_feature_list; |
| 813 scoped_feature_list.InitAndEnableFeature( |
| 814 features::kMediaStreamOldVideoConstraints); |
512 MockConstraintFactory factory; | 815 MockConstraintFactory factory; |
513 // Min width of 2056 pixels can not be fulfilled. | 816 // Min width of 2056 pixels can not be fulfilled. |
514 factory.AddAdvanced().width.setMin(2056); | 817 factory.AddAdvanced().width.setMin(2056); |
515 factory.AddAdvanced().width.setMin(641); | 818 factory.AddAdvanced().width.setMin(641); |
516 // Since min width is set to 641 pixels, max width 640 can not be fulfilled. | 819 // Since min width is set to 641 pixels, max width 640 can not be fulfilled. |
517 factory.AddAdvanced().width.setMax(640); | 820 factory.AddAdvanced().width.setMax(640); |
518 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); | 821 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30); |
519 } | 822 } |
520 | 823 |
521 // Test that the source crops to the requested max width and | 824 // Test that the source crops to the requested max width and |
522 // height even though the camera delivers a larger frame. | 825 // height even though the camera delivers a larger frame. |
523 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameOptional640360) { | 826 // Redundant with spec-compliant constraints. |
| 827 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 828 TEST_F(MediaStreamVideoSourceTest, |
| 829 DeliverCroppedVideoFrameOptional640360OldConstraints) { |
| 830 base::test::ScopedFeatureList scoped_feature_list; |
| 831 scoped_feature_list.InitAndEnableFeature( |
| 832 features::kMediaStreamOldVideoConstraints); |
524 MockConstraintFactory factory; | 833 MockConstraintFactory factory; |
525 factory.AddAdvanced().width.setMax(640); | 834 factory.AddAdvanced().width.setMax(640); |
526 factory.AddAdvanced().height.setMax(360); | 835 factory.AddAdvanced().height.setMax(360); |
527 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); | 836 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); |
528 } | 837 } |
529 | 838 |
530 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory640360) { | 839 // Redundant with spec-compliant constraints. |
| 840 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 841 TEST_F(MediaStreamVideoSourceTest, |
| 842 DeliverCroppedVideoFrameMandatory640360OldConstraints) { |
| 843 base::test::ScopedFeatureList scoped_feature_list; |
| 844 scoped_feature_list.InitAndEnableFeature( |
| 845 features::kMediaStreamOldVideoConstraints); |
531 MockConstraintFactory factory; | 846 MockConstraintFactory factory; |
532 factory.basic().width.setMax(640); | 847 factory.basic().width.setMax(640); |
533 factory.basic().height.setMax(360); | 848 factory.basic().height.setMax(360); |
534 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); | 849 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 640, 360); |
535 } | 850 } |
536 | 851 |
537 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameMandatory732489) { | 852 // Redundant with spec-compliant constraints. |
| 853 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 854 TEST_F(MediaStreamVideoSourceTest, |
| 855 DeliverCroppedVideoFrameMandatory732489OldConstraints) { |
| 856 base::test::ScopedFeatureList scoped_feature_list; |
| 857 scoped_feature_list.InitAndEnableFeature( |
| 858 features::kMediaStreamOldVideoConstraints); |
538 MockConstraintFactory factory; | 859 MockConstraintFactory factory; |
539 factory.basic().width.setMax(732); | 860 factory.basic().width.setMax(732); |
540 factory.basic().height.setMax(489); | 861 factory.basic().height.setMax(489); |
541 factory.basic().width.setMin(732); | 862 factory.basic().width.setMin(732); |
542 factory.basic().height.setMin(489); | 863 factory.basic().height.setMin(489); |
543 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 732, 489); | 864 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 732, 489); |
544 } | 865 } |
545 | 866 |
546 // Test that the source crops to the requested max width and | 867 // Test that the source crops to the requested max width and |
547 // height even though the requested frame has odd size. | 868 // height even though the requested frame has odd size. |
548 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame637359) { | 869 // Redundant with spec-compliant constraints. |
| 870 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 871 TEST_F(MediaStreamVideoSourceTest, |
| 872 DeliverCroppedVideoFrame637359OldConstraints) { |
| 873 base::test::ScopedFeatureList scoped_feature_list; |
| 874 scoped_feature_list.InitAndEnableFeature( |
| 875 features::kMediaStreamOldVideoConstraints); |
549 MockConstraintFactory factory; | 876 MockConstraintFactory factory; |
550 factory.AddAdvanced().width.setMax(637); | 877 factory.AddAdvanced().width.setMax(637); |
551 factory.AddAdvanced().height.setMax(359); | 878 factory.AddAdvanced().height.setMax(359); |
552 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 637, 359); | 879 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 637, 359); |
553 } | 880 } |
554 | 881 |
555 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrame320320) { | 882 // Redundant with spec-compliant constraints. |
| 883 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 884 TEST_F(MediaStreamVideoSourceTest, |
| 885 DeliverCroppedVideoFrame320320OldConstraints) { |
| 886 base::test::ScopedFeatureList scoped_feature_list; |
| 887 scoped_feature_list.InitAndEnableFeature( |
| 888 features::kMediaStreamOldVideoConstraints); |
556 MockConstraintFactory factory; | 889 MockConstraintFactory factory; |
557 factory.basic().width.setMax(320); | 890 factory.basic().width.setMax(320); |
558 factory.basic().height.setMax(320); | 891 factory.basic().height.setMax(320); |
559 factory.basic().height.setMin(320); | 892 factory.basic().height.setMin(320); |
560 factory.basic().width.setMax(320); | 893 factory.basic().width.setMax(320); |
561 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 320, 320); | 894 TestSourceCropFrame(640, 480, factory.CreateWebMediaConstraints(), 320, 320); |
562 } | 895 } |
563 | 896 |
564 TEST_F(MediaStreamVideoSourceTest, DeliverSmallerSizeWhenTooLargeMax) { | 897 // Redundant with spec-compliant constraints. |
| 898 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 899 TEST_F(MediaStreamVideoSourceTest, |
| 900 DeliverSmallerSizeWhenTooLargeMaxOldConstraints) { |
| 901 base::test::ScopedFeatureList scoped_feature_list; |
| 902 scoped_feature_list.InitAndEnableFeature( |
| 903 features::kMediaStreamOldVideoConstraints); |
565 MockConstraintFactory factory; | 904 MockConstraintFactory factory; |
566 factory.AddAdvanced().width.setMax(1920); | 905 factory.AddAdvanced().width.setMax(1920); |
567 factory.AddAdvanced().height.setMax(1080); | 906 factory.AddAdvanced().height.setMax(1080); |
568 factory.AddAdvanced().width.setMin(1280); | 907 factory.AddAdvanced().width.setMin(1280); |
569 factory.AddAdvanced().height.setMin(720); | 908 factory.AddAdvanced().height.setMin(720); |
570 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), | 909 TestSourceCropFrame(1280, 720, factory.CreateWebMediaConstraints(), 1280, |
571 1280, 720); | 910 720); |
572 } | 911 } |
573 | 912 |
574 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) { | 913 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 914 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGAOldConstraints) { |
| 915 base::test::ScopedFeatureList scoped_feature_list; |
| 916 scoped_feature_list.InitAndEnableFeature( |
| 917 features::kMediaStreamOldVideoConstraints); |
575 MockConstraintFactory factory1; | 918 MockConstraintFactory factory1; |
576 factory1.AddAdvanced().width.setMax(640); | 919 factory1.AddAdvanced().width.setMax(640); |
577 factory1.AddAdvanced().height.setMax(480); | 920 factory1.AddAdvanced().height.setMax(480); |
578 | 921 |
579 MockConstraintFactory factory2; | 922 MockConstraintFactory factory2; |
580 factory2.AddAdvanced().height.setMax(360); | 923 factory2.AddAdvanced().height.setMax(360); |
581 | 924 |
582 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 925 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
583 factory2.CreateWebMediaConstraints(), | 926 factory2.CreateWebMediaConstraints(), |
584 640, 480, | 927 640, 480, 640, 480, 640, 360); |
585 640, 480, | |
586 640, 360); | |
587 } | 928 } |
588 | 929 |
589 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) { | 930 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVGAAndWVGA) { |
| 931 base::test::ScopedFeatureList scoped_feature_list; |
| 932 scoped_feature_list.InitAndDisableFeature( |
| 933 features::kMediaStreamOldVideoConstraints); |
| 934 TestTwoTracksWithDifferentSettings(640, 480, 640, 480, 640, 360); |
| 935 } |
| 936 |
| 937 // Redundant with spec-compliant constraints |
| 938 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 939 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGAOldConstraints) { |
| 940 base::test::ScopedFeatureList scoped_feature_list; |
| 941 scoped_feature_list.InitAndEnableFeature( |
| 942 features::kMediaStreamOldVideoConstraints); |
590 MockConstraintFactory factory1; | 943 MockConstraintFactory factory1; |
591 factory1.AddAdvanced().width.setMin(1280); | 944 factory1.AddAdvanced().width.setMin(1280); |
592 factory1.AddAdvanced().height.setMin(720); | 945 factory1.AddAdvanced().height.setMin(720); |
593 | 946 |
594 MockConstraintFactory factory2; | 947 MockConstraintFactory factory2; |
595 factory2.basic().width.setMax(640); | 948 factory2.basic().width.setMax(640); |
596 factory2.basic().height.setMax(360); | 949 factory2.basic().height.setMax(360); |
597 | 950 |
598 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 951 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
599 factory2.CreateWebMediaConstraints(), | 952 factory2.CreateWebMediaConstraints(), |
600 1280, 720, | 953 1280, 720, 1280, 720, 640, 360); |
601 1280, 720, | |
602 640, 360); | |
603 } | 954 } |
604 | 955 |
605 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndW700H700) { | 956 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndWVGA) { |
| 957 base::test::ScopedFeatureList scoped_feature_list; |
| 958 scoped_feature_list.InitAndDisableFeature( |
| 959 features::kMediaStreamOldVideoConstraints); |
| 960 TestTwoTracksWithDifferentSettings(1280, 720, 1280, 720, 640, 360); |
| 961 } |
| 962 |
| 963 // Redundant with spec-compliant constraints |
| 964 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 965 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndW700H700OldConstraints) { |
| 966 base::test::ScopedFeatureList scoped_feature_list; |
| 967 scoped_feature_list.InitAndEnableFeature( |
| 968 features::kMediaStreamOldVideoConstraints); |
606 MockConstraintFactory factory1; | 969 MockConstraintFactory factory1; |
607 factory1.AddAdvanced().width.setMin(1280); | 970 factory1.AddAdvanced().width.setMin(1280); |
608 factory1.AddAdvanced().height.setMin(720); | 971 factory1.AddAdvanced().height.setMin(720); |
609 | 972 |
610 MockConstraintFactory factory2; | 973 MockConstraintFactory factory2; |
611 factory2.basic().width.setMax(700); | 974 factory2.basic().width.setMax(700); |
612 factory2.basic().height.setMax(700); | 975 factory2.basic().height.setMax(700); |
613 | 976 |
614 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 977 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
615 factory2.CreateWebMediaConstraints(), | 978 factory2.CreateWebMediaConstraints(), |
616 1280, 720, | 979 1280, 720, 1280, 720, 700, 700); |
617 1280, 720, | |
618 700, 700); | |
619 } | 980 } |
620 | 981 |
621 TEST_F(MediaStreamVideoSourceTest, TwoTracksWith720AndMaxAspectRatio4To3) { | 982 // Redundant with spec-compliant constraints |
| 983 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 984 TEST_F(MediaStreamVideoSourceTest, |
| 985 TwoTracksWith720AndMaxAspectRatio4To3OldConstraints) { |
| 986 base::test::ScopedFeatureList scoped_feature_list; |
| 987 scoped_feature_list.InitAndEnableFeature( |
| 988 features::kMediaStreamOldVideoConstraints); |
622 MockConstraintFactory factory1; | 989 MockConstraintFactory factory1; |
623 factory1.AddAdvanced().width.setMin(1280); | 990 factory1.AddAdvanced().width.setMin(1280); |
624 factory1.AddAdvanced().height.setMin(720); | 991 factory1.AddAdvanced().height.setMin(720); |
625 | 992 |
626 MockConstraintFactory factory2; | 993 MockConstraintFactory factory2; |
627 factory2.basic().aspectRatio.setMax(640.0 / 480); | 994 factory2.basic().aspectRatio.setMax(640.0 / 480); |
628 | 995 |
629 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 996 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
630 factory2.CreateWebMediaConstraints(), | 997 factory2.CreateWebMediaConstraints(), |
631 1280, 720, | 998 1280, 720, 1280, 720, 960, 720); |
632 1280, 720, | |
633 960, 720); | |
634 } | 999 } |
635 | 1000 |
636 TEST_F(MediaStreamVideoSourceTest, TwoTracksWithVgaAndMinAspectRatio) { | 1001 // Redundant with spec-compliant constraints |
| 1002 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1003 TEST_F(MediaStreamVideoSourceTest, |
| 1004 TwoTracksWithVgaAndMinAspectRatioOldConstraints) { |
| 1005 base::test::ScopedFeatureList scoped_feature_list; |
| 1006 scoped_feature_list.InitAndEnableFeature( |
| 1007 features::kMediaStreamOldVideoConstraints); |
637 MockConstraintFactory factory1; | 1008 MockConstraintFactory factory1; |
638 factory1.AddAdvanced().width.setMax(640); | 1009 factory1.AddAdvanced().width.setMax(640); |
639 factory1.AddAdvanced().height.setMax(480); | 1010 factory1.AddAdvanced().height.setMax(480); |
640 | 1011 |
641 MockConstraintFactory factory2; | 1012 MockConstraintFactory factory2; |
642 factory2.basic().aspectRatio.setMin(640.0 / 360); | 1013 factory2.basic().aspectRatio.setMin(640.0 / 360); |
643 | 1014 |
644 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), | 1015 TestTwoTracksWithDifferentConstraints(factory1.CreateWebMediaConstraints(), |
645 factory2.CreateWebMediaConstraints(), | 1016 factory2.CreateWebMediaConstraints(), |
646 640, 480, | 1017 640, 480, 640, 480, 640, 360); |
647 640, 480, | |
648 640, 360); | |
649 } | 1018 } |
650 | 1019 |
| 1020 // Does not apply with spec-compliant constraints |
| 1021 // TODO(guidou): Remove this test. http://crbug.com/706408 |
651 TEST_F(MediaStreamVideoSourceTest, | 1022 TEST_F(MediaStreamVideoSourceTest, |
652 TwoTracksWithSecondTrackFrameRateHigherThanFirst) { | 1023 TwoTracksWithSecondTrackFrameRateHigherThanFirstOldConstraints) { |
| 1024 base::test::ScopedFeatureList scoped_feature_list; |
| 1025 scoped_feature_list.InitAndEnableFeature( |
| 1026 features::kMediaStreamOldVideoConstraints); |
653 MockConstraintFactory factory1; | 1027 MockConstraintFactory factory1; |
654 factory1.basic().frameRate.setMin(15); | 1028 factory1.basic().frameRate.setMin(15); |
655 factory1.basic().frameRate.setMax(15); | 1029 factory1.basic().frameRate.setMax(15); |
656 | 1030 |
657 blink::WebMediaStreamTrack track1 = | 1031 blink::WebMediaStreamTrack track1 = |
658 CreateTrackAndStartSource(factory1.CreateWebMediaConstraints(), | 1032 CreateTrackAndStartSource(factory1.CreateWebMediaConstraints(), |
659 MediaStreamVideoSource::kDefaultWidth, | 1033 MediaStreamVideoSource::kDefaultWidth, |
660 MediaStreamVideoSource::kDefaultHeight, | 1034 MediaStreamVideoSource::kDefaultHeight, 15); |
661 15); | |
662 | 1035 |
663 MockConstraintFactory factory2; | 1036 MockConstraintFactory factory2; |
664 factory2.basic().frameRate.setMin(30); | 1037 factory2.basic().frameRate.setMin(30); |
665 blink::WebMediaStreamTrack track2 = CreateTrack( | 1038 blink::WebMediaStreamTrack track2 = |
666 "123", factory2.CreateWebMediaConstraints()); | 1039 CreateTrack("123", factory2.CreateWebMediaConstraints()); |
667 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 1040 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
668 } | 1041 } |
669 | 1042 |
670 // Test that a source can change the frame resolution on the fly and that | 1043 // Test that a source can change the frame resolution on the fly and that |
671 // tracks sinks get the new frame size unless constraints force the frame to be | 1044 // tracks sinks get the new frame size unless constraints force the frame to be |
672 // cropped. | 1045 // cropped. |
673 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) { | 1046 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1047 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSizeOldConstraints) { |
| 1048 base::test::ScopedFeatureList scoped_feature_list; |
| 1049 scoped_feature_list.InitAndEnableFeature( |
| 1050 features::kMediaStreamOldVideoConstraints); |
674 MockConstraintFactory factory; | 1051 MockConstraintFactory factory; |
675 factory.AddAdvanced().width.setMax(800); | 1052 factory.AddAdvanced().width.setMax(800); |
676 factory.AddAdvanced().height.setMax(700); | 1053 factory.AddAdvanced().height.setMax(700); |
677 | 1054 |
678 // Expect the source to start capture with the supported resolution. | 1055 // Expect the source to start capture with the supported resolution. |
679 blink::WebMediaStreamTrack track = | 1056 // Disable frame-rate adjustment in spec-compliant mode to ensure no frames |
680 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), | 1057 // are dropped. |
681 640, 480, 30); | 1058 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( |
| 1059 factory.CreateWebMediaConstraints(), 640, 480, 30); |
682 | 1060 |
683 MockMediaStreamVideoSink sink; | 1061 MockMediaStreamVideoSink sink; |
684 sink.ConnectToTrack(track); | 1062 sink.ConnectToTrack(track); |
685 EXPECT_EQ(0, sink.number_of_frames()); | 1063 EXPECT_EQ(0, sink.number_of_frames()); |
686 DeliverVideoFrameAndWaitForRenderer(320, 240, &sink); | 1064 DeliverVideoFrameAndWaitForRenderer(320, 240, &sink); |
687 EXPECT_EQ(1, sink.number_of_frames()); | 1065 EXPECT_EQ(1, sink.number_of_frames()); |
688 // Expect the delivered frame to be passed unchanged since its smaller than | 1066 // Expect the delivered frame to be passed unchanged since its smaller than |
689 // max requested. | 1067 // max requested. |
690 EXPECT_EQ(320, sink.frame_size().width()); | 1068 EXPECT_EQ(320, sink.frame_size().width()); |
691 EXPECT_EQ(240, sink.frame_size().height()); | 1069 EXPECT_EQ(240, sink.frame_size().height()); |
692 | 1070 |
693 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); | 1071 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); |
694 EXPECT_EQ(2, sink.number_of_frames()); | 1072 EXPECT_EQ(2, sink.number_of_frames()); |
695 // Expect the delivered frame to be passed unchanged since its smaller than | 1073 // Expect the delivered frame to be passed unchanged since its smaller than |
696 // max requested. | 1074 // max requested. |
697 EXPECT_EQ(640, sink.frame_size().width()); | 1075 EXPECT_EQ(640, sink.frame_size().width()); |
698 EXPECT_EQ(480, sink.frame_size().height()); | 1076 EXPECT_EQ(480, sink.frame_size().height()); |
699 | 1077 |
700 DeliverVideoFrameAndWaitForRenderer(1280, 720, &sink); | 1078 DeliverVideoFrameAndWaitForRenderer(1280, 720, &sink); |
701 | |
702 EXPECT_EQ(3, sink.number_of_frames()); | 1079 EXPECT_EQ(3, sink.number_of_frames()); |
703 // Expect a frame to be cropped since its larger than max requested. | 1080 // Expect a frame to be cropped since its larger than max requested. |
704 EXPECT_EQ(800, sink.frame_size().width()); | 1081 EXPECT_EQ(800, sink.frame_size().width()); |
| 1082 EXPECT_EQ(700, sink.frame_size().height()); |
| 1083 |
| 1084 sink.DisconnectFromTrack(); |
| 1085 } |
| 1086 |
| 1087 TEST_F(MediaStreamVideoSourceTest, SourceChangeFrameSize) { |
| 1088 base::test::ScopedFeatureList scoped_feature_list; |
| 1089 scoped_feature_list.InitAndDisableFeature( |
| 1090 features::kMediaStreamOldVideoConstraints); |
| 1091 MockConstraintFactory factory; |
| 1092 factory.AddAdvanced().width.setMax(800); |
| 1093 factory.AddAdvanced().height.setMax(700); |
| 1094 |
| 1095 // Expect the source to start capture with the supported resolution. |
| 1096 // Disable frame-rate adjustment in spec-compliant mode to ensure no frames |
| 1097 // are dropped. |
| 1098 blink::WebMediaStreamTrack track = CreateTrackAndStartSource(800, 700, 0.0); |
| 1099 |
| 1100 MockMediaStreamVideoSink sink; |
| 1101 sink.ConnectToTrack(track); |
| 1102 EXPECT_EQ(0, sink.number_of_frames()); |
| 1103 DeliverVideoFrameAndWaitForRenderer(320, 240, &sink); |
| 1104 EXPECT_EQ(1, sink.number_of_frames()); |
| 1105 // Expect the delivered frame to be passed unchanged since its smaller than |
| 1106 // max requested. |
| 1107 EXPECT_EQ(320, sink.frame_size().width()); |
| 1108 EXPECT_EQ(240, sink.frame_size().height()); |
| 1109 |
| 1110 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); |
| 1111 EXPECT_EQ(2, sink.number_of_frames()); |
| 1112 // Expect the delivered frame to be passed unchanged since its smaller than |
| 1113 // max requested. |
| 1114 EXPECT_EQ(640, sink.frame_size().width()); |
| 1115 EXPECT_EQ(480, sink.frame_size().height()); |
| 1116 |
| 1117 DeliverVideoFrameAndWaitForRenderer(1280, 720, &sink); |
| 1118 EXPECT_EQ(3, sink.number_of_frames()); |
| 1119 // Expect a frame to be cropped since its larger than max requested. |
| 1120 EXPECT_EQ(800, sink.frame_size().width()); |
705 EXPECT_EQ(700, sink.frame_size().height()); | 1121 EXPECT_EQ(700, sink.frame_size().height()); |
706 | 1122 |
707 sink.DisconnectFromTrack(); | 1123 sink.DisconnectFromTrack(); |
708 } | 1124 } |
709 | 1125 |
710 // Test that the constraint negotiation can handle 0.0 fps as frame rate. | 1126 // Test that the constraint negotiation can handle 0.0 fps as frame rate. |
711 TEST_F(MediaStreamVideoSourceTest, Use0FpsSupportedFormat) { | 1127 // Does not apply to spec-compliant constraints. |
| 1128 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1129 TEST_F(MediaStreamVideoSourceTest, Use0FpsSupportedFormatOldConstraints) { |
| 1130 base::test::ScopedFeatureList scoped_feature_list; |
| 1131 scoped_feature_list.InitAndEnableFeature( |
| 1132 features::kMediaStreamOldVideoConstraints); |
712 media::VideoCaptureFormats formats; | 1133 media::VideoCaptureFormats formats; |
713 formats.push_back(media::VideoCaptureFormat( | 1134 formats.push_back(media::VideoCaptureFormat(gfx::Size(640, 480), 0.0f, |
714 gfx::Size(640, 480), 0.0f, media::PIXEL_FORMAT_I420)); | 1135 media::PIXEL_FORMAT_I420)); |
715 formats.push_back(media::VideoCaptureFormat( | 1136 formats.push_back(media::VideoCaptureFormat(gfx::Size(320, 240), 0.0f, |
716 gfx::Size(320, 240), 0.0f, media::PIXEL_FORMAT_I420)); | 1137 media::PIXEL_FORMAT_I420)); |
717 mock_source()->SetSupportedFormats(formats); | 1138 mock_source()->SetSupportedFormats(formats); |
718 | 1139 |
719 blink::WebMediaConstraints constraints; | 1140 blink::WebMediaConstraints constraints; |
720 constraints.initialize(); | 1141 constraints.initialize(); |
721 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); | 1142 blink::WebMediaStreamTrack track = CreateTrack("123", constraints); |
722 mock_source()->CompleteGetSupportedFormats(); | 1143 mock_source()->CompleteGetSupportedFormats(); |
723 mock_source()->StartMockedSource(); | 1144 mock_source()->StartMockedSource(); |
724 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); | 1145 EXPECT_EQ(1, NumberOfSuccessConstraintsCallbacks()); |
725 | 1146 |
726 MockMediaStreamVideoSink sink; | 1147 MockMediaStreamVideoSink sink; |
727 sink.ConnectToTrack(track); | 1148 sink.ConnectToTrack(track); |
728 EXPECT_EQ(0, sink.number_of_frames()); | 1149 EXPECT_EQ(0, sink.number_of_frames()); |
729 DeliverVideoFrameAndWaitForRenderer(320, 240, &sink); | 1150 DeliverVideoFrameAndWaitForRenderer(320, 240, &sink); |
730 EXPECT_EQ(1, sink.number_of_frames()); | 1151 EXPECT_EQ(1, sink.number_of_frames()); |
731 // Expect the delivered frame to be passed unchanged since its smaller than | 1152 // Expect the delivered frame to be passed unchanged since its smaller than |
732 // max requested. | 1153 // max requested. |
733 EXPECT_EQ(320, sink.frame_size().width()); | 1154 EXPECT_EQ(320, sink.frame_size().width()); |
734 EXPECT_EQ(240, sink.frame_size().height()); | 1155 EXPECT_EQ(240, sink.frame_size().height()); |
735 sink.DisconnectFromTrack(); | 1156 sink.DisconnectFromTrack(); |
736 } | 1157 } |
737 | 1158 |
738 // Test that a source producing no frames change the source ReadyState to muted. | 1159 // Test that a source producing no frames change the source ReadyState to muted. |
739 // that in a reasonable time frame the muted state turns to false. | 1160 // that in a reasonable time frame the muted state turns to false. |
740 TEST_F(MediaStreamVideoSourceTest, MutedSource) { | 1161 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1162 TEST_F(MediaStreamVideoSourceTest, MutedSourceOldConstraints) { |
| 1163 base::test::ScopedFeatureList scoped_feature_list; |
| 1164 scoped_feature_list.InitAndEnableFeature( |
| 1165 features::kMediaStreamOldVideoConstraints); |
741 // Setup the source for support a frame rate of 999 fps in order to test | 1166 // Setup the source for support a frame rate of 999 fps in order to test |
742 // the muted event faster. This is since the frame monitoring uses | 1167 // the muted event faster. This is since the frame monitoring uses |
743 // PostDelayedTask that is dependent on the source frame rate. | 1168 // PostDelayedTask that is dependent on the source frame rate. |
744 // Note that media::limits::kMaxFramesPerSecond is 1000. | 1169 // Note that media::limits::kMaxFramesPerSecond is 1000. |
745 media::VideoCaptureFormats formats; | 1170 media::VideoCaptureFormats formats; |
746 formats.push_back(media::VideoCaptureFormat( | 1171 formats.push_back(media::VideoCaptureFormat( |
747 gfx::Size(640, 480), media::limits::kMaxFramesPerSecond - 1, | 1172 gfx::Size(640, 480), media::limits::kMaxFramesPerSecond - 1, |
748 media::PIXEL_FORMAT_I420)); | 1173 media::PIXEL_FORMAT_I420)); |
749 SetSourceSupportedFormats(formats); | 1174 SetSourceSupportedFormats(formats); |
750 | 1175 |
751 MockConstraintFactory factory; | 1176 MockConstraintFactory factory; |
752 blink::WebMediaStreamTrack track = | 1177 blink::WebMediaStreamTrack track = |
753 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480, | 1178 CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 640, 480, |
754 media::limits::kMaxFramesPerSecond - 1); | 1179 media::limits::kMaxFramesPerSecond - 1); |
| 1180 |
755 MockMediaStreamVideoSink sink; | 1181 MockMediaStreamVideoSink sink; |
756 sink.ConnectToTrack(track); | 1182 sink.ConnectToTrack(track); |
757 EXPECT_EQ(track.source().getReadyState(), | 1183 EXPECT_EQ(track.source().getReadyState(), |
| 1184 blink::WebMediaStreamSource::ReadyStateLive); |
| 1185 |
| 1186 base::RunLoop run_loop; |
| 1187 base::Closure quit_closure = run_loop.QuitClosure(); |
| 1188 bool muted_state = false; |
| 1189 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) |
| 1190 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure))); |
| 1191 run_loop.Run(); |
| 1192 EXPECT_EQ(muted_state, true); |
| 1193 |
| 1194 EXPECT_EQ(track.source().getReadyState(), |
| 1195 blink::WebMediaStreamSource::ReadyStateMuted); |
| 1196 |
| 1197 base::RunLoop run_loop2; |
| 1198 base::Closure quit_closure2 = run_loop2.QuitClosure(); |
| 1199 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) |
| 1200 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure2))); |
| 1201 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); |
| 1202 run_loop2.Run(); |
| 1203 |
| 1204 EXPECT_EQ(muted_state, false); |
| 1205 EXPECT_EQ(track.source().getReadyState(), |
| 1206 blink::WebMediaStreamSource::ReadyStateLive); |
| 1207 |
| 1208 sink.DisconnectFromTrack(); |
| 1209 } |
| 1210 |
| 1211 // Test that a source producing no frames change the source ReadyState to muted. |
| 1212 // that in a reasonable time frame the muted state turns to false. |
| 1213 TEST_F(MediaStreamVideoSourceTest, MutedSource) { |
| 1214 base::test::ScopedFeatureList scoped_feature_list; |
| 1215 scoped_feature_list.InitAndDisableFeature( |
| 1216 features::kMediaStreamOldVideoConstraints); |
| 1217 // Setup the source for support a frame rate of 999 fps in order to test |
| 1218 // the muted event faster. This is since the frame monitoring uses |
| 1219 // PostDelayedTask that is dependent on the source frame rate. |
| 1220 // Note that media::limits::kMaxFramesPerSecond is 1000. |
| 1221 blink::WebMediaStreamTrack track = CreateTrackAndStartSource( |
| 1222 640, 480, media::limits::kMaxFramesPerSecond - 2); |
| 1223 MockMediaStreamVideoSink sink; |
| 1224 sink.ConnectToTrack(track); |
| 1225 EXPECT_EQ(track.source().getReadyState(), |
758 blink::WebMediaStreamSource::ReadyStateLive); | 1226 blink::WebMediaStreamSource::ReadyStateLive); |
759 | 1227 |
760 base::RunLoop run_loop; | 1228 base::RunLoop run_loop; |
761 base::Closure quit_closure = run_loop.QuitClosure(); | 1229 base::Closure quit_closure = run_loop.QuitClosure(); |
762 bool muted_state = false; | 1230 bool muted_state = false; |
763 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) | 1231 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) |
764 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure))); | 1232 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure))); |
765 run_loop.Run(); | 1233 run_loop.Run(); |
766 EXPECT_EQ(muted_state, true); | 1234 EXPECT_EQ(muted_state, true); |
767 | 1235 |
768 EXPECT_EQ(track.source().getReadyState(), | 1236 EXPECT_EQ(track.source().getReadyState(), |
769 blink::WebMediaStreamSource::ReadyStateMuted); | 1237 blink::WebMediaStreamSource::ReadyStateMuted); |
770 | 1238 |
771 base::RunLoop run_loop2; | 1239 base::RunLoop run_loop2; |
772 base::Closure quit_closure2 = run_loop2.QuitClosure(); | 1240 base::Closure quit_closure2 = run_loop2.QuitClosure(); |
773 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) | 1241 EXPECT_CALL(*mock_source(), DoSetMutedState(_)) |
774 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure2))); | 1242 .WillOnce(DoAll(SaveArg<0>(&muted_state), RunClosure(quit_closure2))); |
775 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); | 1243 DeliverVideoFrameAndWaitForRenderer(640, 480, &sink); |
776 run_loop2.Run(); | 1244 run_loop2.Run(); |
777 | 1245 |
778 EXPECT_EQ(muted_state, false); | 1246 EXPECT_EQ(muted_state, false); |
779 EXPECT_EQ(track.source().getReadyState(), | 1247 EXPECT_EQ(track.source().getReadyState(), |
780 blink::WebMediaStreamSource::ReadyStateLive); | 1248 blink::WebMediaStreamSource::ReadyStateLive); |
781 | 1249 |
782 sink.DisconnectFromTrack(); | 1250 sink.DisconnectFromTrack(); |
783 } | 1251 } |
784 | 1252 |
785 // Test that an optional constraint with an invalid aspect ratio is ignored. | 1253 // Test that an optional constraint with an invalid aspect ratio is ignored. |
786 TEST_F(MediaStreamVideoSourceTest, InvalidOptionalAspectRatioIgnored) { | 1254 // Does not apply with spec-compliant constraints. |
| 1255 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1256 TEST_F(MediaStreamVideoSourceTest, |
| 1257 InvalidOptionalAspectRatioIgnoredOldConstraints) { |
| 1258 base::test::ScopedFeatureList scoped_feature_list; |
| 1259 scoped_feature_list.InitAndEnableFeature( |
| 1260 features::kMediaStreamOldVideoConstraints); |
787 MockConstraintFactory factory; | 1261 MockConstraintFactory factory; |
788 factory.AddAdvanced().aspectRatio.setMax(0.0); | 1262 factory.AddAdvanced().aspectRatio.setMax(0.0); |
789 blink::WebMediaStreamTrack track = | 1263 blink::WebMediaStreamTrack track = |
790 CreateTrack("123", factory.CreateWebMediaConstraints()); | 1264 CreateTrack("123", factory.CreateWebMediaConstraints()); |
791 mock_source()->CompleteGetSupportedFormats(); | 1265 mock_source()->CompleteGetSupportedFormats(); |
792 EXPECT_EQ(0, NumberOfFailedConstraintsCallbacks()); | 1266 EXPECT_EQ(0, NumberOfFailedConstraintsCallbacks()); |
793 } | 1267 } |
794 | 1268 |
795 // Test that setting an invalid mandatory aspect ratio fails. | 1269 // Test that setting an invalid mandatory aspect ratio fails. |
796 TEST_F(MediaStreamVideoSourceTest, InvalidMandatoryAspectRatioFails) { | 1270 // Does not apply with spec-compliant constraints. |
| 1271 // TODO(guidou): Remove this test. http://crbug.com/706408 |
| 1272 TEST_F(MediaStreamVideoSourceTest, |
| 1273 InvalidMandatoryAspectRatioFailsOldConstraints) { |
| 1274 base::test::ScopedFeatureList scoped_feature_list; |
| 1275 scoped_feature_list.InitAndEnableFeature( |
| 1276 features::kMediaStreamOldVideoConstraints); |
797 MockConstraintFactory factory; | 1277 MockConstraintFactory factory; |
798 factory.basic().aspectRatio.setMax(0.0); | 1278 factory.basic().aspectRatio.setMax(0.0); |
799 blink::WebMediaStreamTrack track = | 1279 blink::WebMediaStreamTrack track = |
800 CreateTrack("123", factory.CreateWebMediaConstraints()); | 1280 CreateTrack("123", factory.CreateWebMediaConstraints()); |
801 mock_source()->CompleteGetSupportedFormats(); | 1281 mock_source()->CompleteGetSupportedFormats(); |
802 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); | 1282 EXPECT_EQ(1, NumberOfFailedConstraintsCallbacks()); |
803 } | 1283 } |
804 | 1284 |
805 } // namespace content | 1285 } // namespace content |
OLD | NEW |