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 <stdint.h> | 5 #include <stdint.h> |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/run_loop.h" | 11 #include "base/run_loop.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 "base/threading/thread_checker_impl.h" | 14 #include "base/threading/thread_checker_impl.h" |
14 #include "content/child/child_process.h" | 15 #include "content/child/child_process.h" |
16 #include "content/public/common/content_features.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_media_stream_video_sink.h" | 18 #include "content/renderer/media/mock_media_stream_video_sink.h" |
17 #include "content/renderer/media/mock_media_stream_video_source.h" | 19 #include "content/renderer/media/mock_media_stream_video_source.h" |
18 #include "media/base/video_frame.h" | 20 #include "media/base/video_frame.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
20 #include "third_party/WebKit/public/web/WebHeap.h" | 22 #include "third_party/WebKit/public/web/WebHeap.h" |
21 | 23 |
22 namespace content { | 24 namespace content { |
23 | 25 |
24 const uint8_t kBlackValue = 0x00; | 26 const uint8_t kBlackValue = 0x00; |
25 const uint8_t kColorValue = 0xAB; | 27 const uint8_t kColorValue = 0xAB; |
28 const int kMockSourceWidth = 640; | |
29 const int kMockSourceHeight = 480; | |
26 | 30 |
27 ACTION_P(RunClosure, closure) { | 31 ACTION_P(RunClosure, closure) { |
28 closure.Run(); | 32 closure.Run(); |
29 } | 33 } |
30 | 34 |
31 class MediaStreamVideoTrackTest : public ::testing::Test { | 35 class MediaStreamVideoTrackTest : public ::testing::Test { |
32 public: | 36 public: |
33 MediaStreamVideoTrackTest() | 37 MediaStreamVideoTrackTest() |
34 : child_process_(new ChildProcess()), | 38 : child_process_(new ChildProcess()), |
35 mock_source_(new MockMediaStreamVideoSource(false)), | 39 mock_source_(nullptr), |
36 source_started_(false) { | 40 source_started_(false) {} |
37 blink_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), | |
38 blink::WebMediaStreamSource::TypeVideo, | |
39 blink::WebString::fromASCII("dummy_source_name"), | |
40 false /* remote */); | |
41 blink_source_.setExtraData(mock_source_); | |
42 } | |
43 | 41 |
44 ~MediaStreamVideoTrackTest() override {} | 42 ~MediaStreamVideoTrackTest() override {} |
45 | 43 |
46 void TearDown() override { | 44 void TearDown() override { |
47 blink_source_.reset(); | 45 blink_source_.reset(); |
48 blink::WebHeap::collectAllGarbageForTesting(); | 46 blink::WebHeap::collectAllGarbageForTesting(); |
49 } | 47 } |
50 | 48 |
51 void DeliverVideoFrameAndWaitForRenderer(MockMediaStreamVideoSink* sink) { | 49 void DeliverVideoFrameAndWaitForRenderer(MockMediaStreamVideoSink* sink) { |
52 base::RunLoop run_loop; | 50 base::RunLoop run_loop; |
53 base::Closure quit_closure = run_loop.QuitClosure(); | 51 base::Closure quit_closure = run_loop.QuitClosure(); |
54 EXPECT_CALL(*sink, OnVideoFrame()).WillOnce(RunClosure(quit_closure)); | 52 EXPECT_CALL(*sink, OnVideoFrame()).WillOnce(RunClosure(quit_closure)); |
55 const scoped_refptr<media::VideoFrame> frame = | 53 const scoped_refptr<media::VideoFrame> frame = |
56 media::VideoFrame::CreateColorFrame( | 54 media::VideoFrame::CreateColorFrame( |
57 gfx::Size(MediaStreamVideoSource::kDefaultWidth, | 55 gfx::Size(MediaStreamVideoSource::kDefaultWidth, |
58 MediaStreamVideoSource::kDefaultHeight), | 56 MediaStreamVideoSource::kDefaultHeight), |
59 kColorValue, kColorValue, kColorValue, base::TimeDelta()); | 57 kColorValue, kColorValue, kColorValue, base::TimeDelta()); |
60 mock_source()->DeliverVideoFrame(frame); | 58 mock_source()->DeliverVideoFrame(frame); |
61 run_loop.Run(); | 59 run_loop.Run(); |
62 } | 60 } |
63 | 61 |
64 protected: | 62 protected: |
65 base::MessageLoop* io_message_loop() const { | 63 base::MessageLoop* io_message_loop() const { |
66 return child_process_->io_message_loop(); | 64 return child_process_->io_message_loop(); |
67 } | 65 } |
68 | 66 |
67 void InitializeSource() { | |
68 blink_source_.reset(); | |
69 mock_source_ = IsOldVideoConstraints() | |
70 ? new MockMediaStreamVideoSource(false) | |
71 : new MockMediaStreamVideoSource( | |
72 media::VideoCaptureFormat( | |
73 gfx::Size(kMockSourceWidth, kMockSourceHeight), | |
74 30.0, media::PIXEL_FORMAT_I420), | |
75 false); | |
76 blink_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), | |
77 blink::WebMediaStreamSource::TypeVideo, | |
78 blink::WebString::fromASCII("dummy_source_name"), | |
79 false /* remote */); | |
80 blink_source_.setExtraData(mock_source_); | |
81 } | |
82 | |
69 // Create a track that's associated with |mock_source_|. | 83 // Create a track that's associated with |mock_source_|. |
70 blink::WebMediaStreamTrack CreateTrack() { | 84 blink::WebMediaStreamTrack CreateTrack() { |
71 blink::WebMediaConstraints constraints; | |
72 constraints.initialize(); | |
73 const bool enabled = true; | 85 const bool enabled = true; |
74 blink::WebMediaStreamTrack track = | 86 blink::WebMediaStreamTrack track = MediaStreamVideoTrack::CreateVideoTrack( |
75 MediaStreamVideoTrack::CreateVideoTrack( | 87 mock_source_, MediaStreamSource::ConstraintsCallback(), enabled); |
76 mock_source_, constraints, | |
77 MediaStreamSource::ConstraintsCallback(), enabled); | |
78 if (!source_started_) { | 88 if (!source_started_) { |
79 mock_source_->StartMockedSource(); | 89 mock_source_->StartMockedSource(); |
80 source_started_ = true; | 90 source_started_ = true; |
81 } | 91 } |
82 return track; | 92 return track; |
83 } | 93 } |
84 | 94 |
85 void UpdateVideoSourceToRespondToRequestRefreshFrame() { | 95 void UpdateVideoSourceToRespondToRequestRefreshFrame() { |
86 blink_source_.reset(); | 96 blink_source_.reset(); |
87 mock_source_ = new MockMediaStreamVideoSource(false, true); | 97 mock_source_ = IsOldVideoConstraints() |
98 ? new MockMediaStreamVideoSource(false, true) | |
99 : new MockMediaStreamVideoSource( | |
100 media::VideoCaptureFormat( | |
101 gfx::Size(kMockSourceWidth, kMockSourceHeight), | |
102 30.0, media::PIXEL_FORMAT_I420), | |
103 true); | |
88 blink_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), | 104 blink_source_.initialize(blink::WebString::fromASCII("dummy_source_id"), |
89 blink::WebMediaStreamSource::TypeVideo, | 105 blink::WebMediaStreamSource::TypeVideo, |
90 blink::WebString::fromASCII("dummy_source_name"), | 106 blink::WebString::fromASCII("dummy_source_name"), |
91 false /* remote */); | 107 false /* remote */); |
92 blink_source_.setExtraData(mock_source_); | 108 blink_source_.setExtraData(mock_source_); |
93 } | 109 } |
94 | 110 |
95 MockMediaStreamVideoSource* mock_source() { return mock_source_; } | 111 MockMediaStreamVideoSource* mock_source() { return mock_source_; } |
96 const blink::WebMediaStreamSource& blink_source() const { | 112 const blink::WebMediaStreamSource& blink_source() const { |
97 return blink_source_; | 113 return blink_source_; |
98 } | 114 } |
99 | 115 |
100 private: | 116 private: |
101 const base::MessageLoopForUI message_loop_; | 117 const base::MessageLoopForUI message_loop_; |
102 const std::unique_ptr<ChildProcess> child_process_; | 118 const std::unique_ptr<ChildProcess> child_process_; |
103 blink::WebMediaStreamSource blink_source_; | 119 blink::WebMediaStreamSource blink_source_; |
104 // |mock_source_| is owned by |webkit_source_|. | 120 // |mock_source_| is owned by |webkit_source_|. |
105 MockMediaStreamVideoSource* mock_source_; | 121 MockMediaStreamVideoSource* mock_source_; |
106 bool source_started_; | 122 bool source_started_; |
107 }; | 123 }; |
108 | 124 |
109 TEST_F(MediaStreamVideoTrackTest, AddAndRemoveSink) { | 125 TEST_F(MediaStreamVideoTrackTest, AddAndRemoveSink) { |
126 InitializeSource(); | |
110 MockMediaStreamVideoSink sink; | 127 MockMediaStreamVideoSink sink; |
111 blink::WebMediaStreamTrack track = CreateTrack(); | 128 blink::WebMediaStreamTrack track = CreateTrack(); |
112 sink.ConnectToTrack(track); | 129 sink.ConnectToTrack(track); |
113 | 130 |
114 DeliverVideoFrameAndWaitForRenderer(&sink); | 131 DeliverVideoFrameAndWaitForRenderer(&sink); |
115 EXPECT_EQ(1, sink.number_of_frames()); | 132 EXPECT_EQ(1, sink.number_of_frames()); |
116 | 133 |
117 DeliverVideoFrameAndWaitForRenderer(&sink); | 134 DeliverVideoFrameAndWaitForRenderer(&sink); |
118 | 135 |
119 sink.DisconnectFromTrack(); | 136 sink.DisconnectFromTrack(); |
(...skipping 28 matching lines...) Expand all Loading... | |
148 | 165 |
149 void CheckThreadVideoFrameReceiver( | 166 void CheckThreadVideoFrameReceiver( |
150 CheckThreadHelper* helper, | 167 CheckThreadHelper* helper, |
151 const scoped_refptr<media::VideoFrame>& frame, | 168 const scoped_refptr<media::VideoFrame>& frame, |
152 base::TimeTicks estimated_capture_time) { | 169 base::TimeTicks estimated_capture_time) { |
153 // Do nothing. | 170 // Do nothing. |
154 } | 171 } |
155 | 172 |
156 // Checks that the callback given to the track is reset on the right thread. | 173 // Checks that the callback given to the track is reset on the right thread. |
157 TEST_F(MediaStreamVideoTrackTest, ResetCallbackOnThread) { | 174 TEST_F(MediaStreamVideoTrackTest, ResetCallbackOnThread) { |
175 InitializeSource(); | |
158 MockMediaStreamVideoSink sink; | 176 MockMediaStreamVideoSink sink; |
159 blink::WebMediaStreamTrack track = CreateTrack(); | 177 blink::WebMediaStreamTrack track = CreateTrack(); |
160 | 178 |
161 base::RunLoop run_loop; | 179 base::RunLoop run_loop; |
162 bool correct = false; | 180 bool correct = false; |
163 sink.ConnectToTrackWithCallback( | 181 sink.ConnectToTrackWithCallback( |
164 track, | 182 track, |
165 base::Bind(&CheckThreadVideoFrameReceiver, | 183 base::Bind(&CheckThreadVideoFrameReceiver, |
166 base::Owned(new CheckThreadHelper(run_loop.QuitClosure(), | 184 base::Owned(new CheckThreadHelper(run_loop.QuitClosure(), |
167 &correct)))); | 185 &correct)))); |
168 sink.DisconnectFromTrack(); | 186 sink.DisconnectFromTrack(); |
169 run_loop.Run(); | 187 run_loop.Run(); |
170 EXPECT_TRUE(correct) << "Not called on correct thread."; | 188 EXPECT_TRUE(correct) << "Not called on correct thread."; |
171 } | 189 } |
172 | 190 |
173 TEST_F(MediaStreamVideoTrackTest, SetEnabled) { | 191 TEST_F(MediaStreamVideoTrackTest, SetEnabled) { |
192 InitializeSource(); | |
174 MockMediaStreamVideoSink sink; | 193 MockMediaStreamVideoSink sink; |
175 blink::WebMediaStreamTrack track = CreateTrack(); | 194 blink::WebMediaStreamTrack track = CreateTrack(); |
176 sink.ConnectToTrack(track); | 195 sink.ConnectToTrack(track); |
177 | 196 |
178 MediaStreamVideoTrack* video_track = | 197 MediaStreamVideoTrack* video_track = |
179 MediaStreamVideoTrack::GetVideoTrack(track); | 198 MediaStreamVideoTrack::GetVideoTrack(track); |
180 | 199 |
181 DeliverVideoFrameAndWaitForRenderer(&sink); | 200 DeliverVideoFrameAndWaitForRenderer(&sink); |
182 EXPECT_EQ(1, sink.number_of_frames()); | 201 EXPECT_EQ(1, sink.number_of_frames()); |
183 EXPECT_EQ(kColorValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); | 202 EXPECT_EQ(kColorValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); |
184 | 203 |
185 video_track->SetEnabled(false); | 204 video_track->SetEnabled(false); |
186 EXPECT_FALSE(sink.enabled()); | 205 EXPECT_FALSE(sink.enabled()); |
187 | 206 |
188 DeliverVideoFrameAndWaitForRenderer(&sink); | 207 DeliverVideoFrameAndWaitForRenderer(&sink); |
189 EXPECT_EQ(2, sink.number_of_frames()); | 208 EXPECT_EQ(2, sink.number_of_frames()); |
190 EXPECT_EQ(kBlackValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); | 209 EXPECT_EQ(kBlackValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); |
191 | 210 |
192 video_track->SetEnabled(true); | 211 video_track->SetEnabled(true); |
193 EXPECT_TRUE(sink.enabled()); | 212 EXPECT_TRUE(sink.enabled()); |
194 DeliverVideoFrameAndWaitForRenderer(&sink); | 213 DeliverVideoFrameAndWaitForRenderer(&sink); |
195 EXPECT_EQ(3, sink.number_of_frames()); | 214 EXPECT_EQ(3, sink.number_of_frames()); |
196 EXPECT_EQ(kColorValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); | 215 EXPECT_EQ(kColorValue, *sink.last_frame()->data(media::VideoFrame::kYPlane)); |
197 sink.DisconnectFromTrack(); | 216 sink.DisconnectFromTrack(); |
198 } | 217 } |
199 | 218 |
200 TEST_F(MediaStreamVideoTrackTest, SourceStopped) { | 219 TEST_F(MediaStreamVideoTrackTest, SourceStopped) { |
220 InitializeSource(); | |
201 MockMediaStreamVideoSink sink; | 221 MockMediaStreamVideoSink sink; |
202 blink::WebMediaStreamTrack track = CreateTrack(); | 222 blink::WebMediaStreamTrack track = CreateTrack(); |
203 sink.ConnectToTrack(track); | 223 sink.ConnectToTrack(track); |
204 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, sink.state()); | 224 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, sink.state()); |
205 | 225 |
206 mock_source()->StopSource(); | 226 mock_source()->StopSource(); |
207 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, sink.state()); | 227 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, sink.state()); |
208 sink.DisconnectFromTrack(); | 228 sink.DisconnectFromTrack(); |
209 } | 229 } |
210 | 230 |
211 TEST_F(MediaStreamVideoTrackTest, StopLastTrack) { | 231 TEST_F(MediaStreamVideoTrackTest, StopLastTrack) { |
232 InitializeSource(); | |
212 MockMediaStreamVideoSink sink1; | 233 MockMediaStreamVideoSink sink1; |
213 blink::WebMediaStreamTrack track1 = CreateTrack(); | 234 blink::WebMediaStreamTrack track1 = CreateTrack(); |
214 sink1.ConnectToTrack(track1); | 235 sink1.ConnectToTrack(track1); |
215 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, sink1.state()); | 236 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, sink1.state()); |
216 | 237 |
217 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, | 238 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive, |
218 blink_source().getReadyState()); | 239 blink_source().getReadyState()); |
219 | 240 |
220 MockMediaStreamVideoSink sink2; | 241 MockMediaStreamVideoSink sink2; |
221 blink::WebMediaStreamTrack track2 = CreateTrack(); | 242 blink::WebMediaStreamTrack track2 = CreateTrack(); |
(...skipping 11 matching lines...) Expand all Loading... | |
233 MediaStreamVideoTrack* const native_track2 = | 254 MediaStreamVideoTrack* const native_track2 = |
234 MediaStreamVideoTrack::GetVideoTrack(track2); | 255 MediaStreamVideoTrack::GetVideoTrack(track2); |
235 native_track2->Stop(); | 256 native_track2->Stop(); |
236 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, sink2.state()); | 257 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, sink2.state()); |
237 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, | 258 EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded, |
238 blink_source().getReadyState()); | 259 blink_source().getReadyState()); |
239 sink2.DisconnectFromTrack(); | 260 sink2.DisconnectFromTrack(); |
240 } | 261 } |
241 | 262 |
242 TEST_F(MediaStreamVideoTrackTest, CheckTrackRequestsFrame) { | 263 TEST_F(MediaStreamVideoTrackTest, CheckTrackRequestsFrame) { |
264 base::test::ScopedFeatureList scoped_feature_list; | |
265 scoped_feature_list.InitAndEnableFeature( | |
266 features::kMediaStreamOldVideoConstraints); | |
243 UpdateVideoSourceToRespondToRequestRefreshFrame(); | 267 UpdateVideoSourceToRespondToRequestRefreshFrame(); |
244 blink::WebMediaStreamTrack track = CreateTrack(); | 268 blink::WebMediaStreamTrack track = CreateTrack(); |
245 | 269 |
270 // Add sink and expect to get a frame. | |
271 MockMediaStreamVideoSink sink; | |
272 base::RunLoop run_loop; | |
273 base::Closure quit_closure = run_loop.QuitClosure(); | |
274 EXPECT_CALL(sink, OnVideoFrame()).WillOnce(RunClosure(quit_closure)); | |
275 sink.ConnectToTrack(track); | |
276 run_loop.Run(); | |
277 EXPECT_EQ(1, sink.number_of_frames()); | |
278 | |
279 sink.DisconnectFromTrack(); | |
280 } | |
281 | |
282 TEST_F(MediaStreamVideoTrackTest, CheckTrackRequestsFrameNew) { | |
hbos_chromium
2017/04/05 12:37:28
Any point in testing with both old and new with TE
Guido Urdaneta
2017/04/05 16:17:17
I think it's not worth it in this case because man
hbos_chromium
2017/04/05 16:56:31
Acknowledged.
| |
283 base::test::ScopedFeatureList scoped_feature_list; | |
284 scoped_feature_list.InitAndDisableFeature( | |
285 features::kMediaStreamOldVideoConstraints); | |
286 InitializeSource(); | |
287 UpdateVideoSourceToRespondToRequestRefreshFrame(); | |
288 blink::WebMediaStreamTrack track = CreateTrack(); | |
289 | |
246 // Add sink and expect to get a frame. | 290 // Add sink and expect to get a frame. |
247 MockMediaStreamVideoSink sink; | 291 MockMediaStreamVideoSink sink; |
248 base::RunLoop run_loop; | 292 base::RunLoop run_loop; |
249 base::Closure quit_closure = run_loop.QuitClosure(); | 293 base::Closure quit_closure = run_loop.QuitClosure(); |
250 EXPECT_CALL(sink, OnVideoFrame()).WillOnce(RunClosure(quit_closure)); | 294 EXPECT_CALL(sink, OnVideoFrame()).WillOnce(RunClosure(quit_closure)); |
251 sink.ConnectToTrack(track); | 295 sink.ConnectToTrack(track); |
252 run_loop.Run(); | 296 run_loop.Run(); |
253 EXPECT_EQ(1, sink.number_of_frames()); | 297 EXPECT_EQ(1, sink.number_of_frames()); |
254 | 298 |
255 sink.DisconnectFromTrack(); | 299 sink.DisconnectFromTrack(); |
256 } | 300 } |
257 | 301 |
258 TEST_F(MediaStreamVideoTrackTest, GetSettings) { | 302 TEST_F(MediaStreamVideoTrackTest, GetSettings) { |
303 base::test::ScopedFeatureList scoped_feature_list; | |
304 scoped_feature_list.InitAndEnableFeature( | |
305 features::kMediaStreamOldVideoConstraints); | |
306 InitializeSource(); | |
259 blink::WebMediaStreamTrack track = CreateTrack(); | 307 blink::WebMediaStreamTrack track = CreateTrack(); |
260 MediaStreamVideoTrack* const native_track = | 308 MediaStreamVideoTrack* const native_track = |
261 MediaStreamVideoTrack::GetVideoTrack(track); | 309 MediaStreamVideoTrack::GetVideoTrack(track); |
310 blink::WebMediaStreamTrack::Settings settings; | |
311 native_track->getSettings(settings); | |
312 // These values come straight from the mock video track implementation. | |
313 EXPECT_EQ(640, settings.width); | |
314 EXPECT_EQ(480, settings.height); | |
315 EXPECT_EQ(30.0, settings.frameRate); | |
316 EXPECT_EQ(blink::WebMediaStreamTrack::FacingMode::None, settings.facingMode); | |
317 } | |
318 | |
319 TEST_F(MediaStreamVideoTrackTest, GetSettingsNew) { | |
320 base::test::ScopedFeatureList scoped_feature_list; | |
321 scoped_feature_list.InitAndDisableFeature( | |
322 features::kMediaStreamOldVideoConstraints); | |
323 InitializeSource(); | |
324 blink::WebMediaStreamTrack track = CreateTrack(); | |
325 MediaStreamVideoTrack* const native_track = | |
326 MediaStreamVideoTrack::GetVideoTrack(track); | |
262 blink::WebMediaStreamTrack::Settings settings; | 327 blink::WebMediaStreamTrack::Settings settings; |
263 native_track->getSettings(settings); | 328 native_track->getSettings(settings); |
264 // These values come straight from the mock video track implementation. | 329 // These values come straight from the mock video track implementation. |
265 EXPECT_EQ(640, settings.width); | 330 EXPECT_EQ(640, settings.width); |
266 EXPECT_EQ(480, settings.height); | 331 EXPECT_EQ(480, settings.height); |
267 EXPECT_EQ(30.0, settings.frameRate); | 332 EXPECT_EQ(30.0, settings.frameRate); |
268 EXPECT_EQ(blink::WebMediaStreamTrack::FacingMode::None, settings.facingMode); | 333 EXPECT_EQ(blink::WebMediaStreamTrack::FacingMode::None, settings.facingMode); |
269 } | 334 } |
270 | 335 |
271 } // namespace content | 336 } // namespace content |
OLD | NEW |