content/browser/media/webrtc_getusermedia_browsertest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/json/json_reader.h"
   7 #include "base/strings/stringprintf.h"
   8 #include "base/test/trace_event_analyzer.h"
   9 #include "base/trace_event/trace_event_impl.h"
  10 #include "base/values.h"
  11 #include "content/browser/media/webrtc_internals.h"
  12 #include "content/browser/web_contents/web_contents_impl.h"
  13 #include "content/public/common/content_switches.h"
  14 #include "content/public/test/browser_test_utils.h"
  15 #include "content/public/test/content_browser_test_utils.h"
  16 #include "content/public/test/test_utils.h"
  17 #include "content/shell/browser/shell.h"
  18 #include "content/test/webrtc_content_browsertest_base.h"
  19 #include "net/test/embedded_test_server/embedded_test_server.h"
  20 #include "testing/perf/perf_test.h"
  21
  22 #if defined(OS_WIN)
  23 #include "base/win/windows_version.h"
  24 #endif
  25
  26 using trace_analyzer::TraceAnalyzer;
  27 using trace_analyzer::Query;
  28 using trace_analyzer::TraceEventVector;
  29
  30 namespace {
  31
  32 static const char kGetUserMediaAndStop[] = "getUserMediaAndStop";
  33 static const char kGetUserMediaAndGetStreamUp[] = "getUserMediaAndGetStreamUp";
  34 static const char kGetUserMediaAndAnalyseAndStop[] =
  35     "getUserMediaAndAnalyseAndStop";
  36 static const char kGetUserMediaAndExpectFailure[] =
  37     "getUserMediaAndExpectFailure";
  38 static const char kRenderSameTrackMediastreamAndStop[] =
  39     "renderSameTrackMediastreamAndStop";
  40 static const char kRenderClonedMediastreamAndStop[] =
  41     "renderClonedMediastreamAndStop";
  42 static const char kRenderClonedTrackMediastreamAndStop[] =
  43     "renderClonedTrackMediastreamAndStop";
  44 static const char kRenderDuplicatedMediastreamAndStop[] =
  45     "renderDuplicatedMediastreamAndStop";
  46
  47 // Results returned by JS.
  48 static const char kOK[] = "OK";
  49
  50 std::string GenerateGetUserMediaWithMandatorySourceID(
  51     const std::string& function_name,
  52     const std::string& audio_source_id,
  53     const std::string& video_source_id) {
  54   const std::string audio_constraint =
  55       "audio: {mandatory: { sourceId:\"" + audio_source_id + "\"}}, ";
  56
  57   const std::string video_constraint =
  58       "video: {mandatory: { sourceId:\"" + video_source_id + "\"}}";
  59   return function_name + "({" + audio_constraint + video_constraint + "});";
  60 }
  61
  62 std::string GenerateGetUserMediaWithOptionalSourceID(
  63     const std::string& function_name,
  64     const std::string& audio_source_id,
  65     const std::string& video_source_id) {
  66   const std::string audio_constraint =
  67       "audio: {optional: [{sourceId:\"" + audio_source_id + "\"}]}, ";
  68
  69   const std::string video_constraint =
  70       "video: {optional: [{ sourceId:\"" + video_source_id + "\"}]}";
  71   return function_name + "({" + audio_constraint + video_constraint + "});";
  72 }
  73
  74 }  // namespace
  75
  76 namespace content {
  77
  78 class WebRtcGetUserMediaBrowserTest: public WebRtcContentBrowserTest {
  79  public:
  80   WebRtcGetUserMediaBrowserTest() : trace_log_(NULL) {}
  81   ~WebRtcGetUserMediaBrowserTest() override {}
  82
  83   void StartTracing() {
  84     CHECK(trace_log_ == NULL) << "Can only can start tracing once";
  85     trace_log_ = base::trace_event::TraceLog::GetInstance();
  86     base::trace_event::TraceConfig trace_config(
  87         "video", base::trace_event::RECORD_UNTIL_FULL);
  88     trace_config.EnableSampling();
  89     trace_log_->SetEnabled(trace_config,
  90                            base::trace_event::TraceLog::RECORDING_MODE);
  91     // Check that we are indeed recording.
  92     EXPECT_EQ(trace_log_->GetNumTracesRecorded(), 1);
  93   }
  94
  95   void StopTracing() {
  96     CHECK(message_loop_runner_.get() == NULL)
  97         << "Calling StopTracing more than once";
  98     trace_log_->SetDisabled();
  99     message_loop_runner_ = new MessageLoopRunner;
 100     trace_log_->Flush(base::Bind(
 101         &WebRtcGetUserMediaBrowserTest::OnTraceDataCollected,
 102         base::Unretained(this)));
 103     message_loop_runner_->Run();
 104   }
 105
 106   void OnTraceDataCollected(
 107       const scoped_refptr<base::RefCountedString>& events_str_ptr,
 108       bool has_more_events) {
 109     CHECK(!has_more_events);
 110     recorded_trace_data_ = events_str_ptr;
 111     message_loop_runner_->Quit();
 112   }
 113
 114   TraceAnalyzer* CreateTraceAnalyzer() {
 115     return TraceAnalyzer::Create("[" + recorded_trace_data_->data() + "]");
 116   }
 117
 118   void RunGetUserMediaAndCollectMeasures(const int time_to_sample_secs,
 119                                          const std::string& measure_filter,
 120                                          const std::string& graph_name) {
 121     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 122
 123     GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 124     NavigateToURL(shell(), url);
 125
 126     // Put getUserMedia to work and let it run for a couple of seconds.
 127     DCHECK(time_to_sample_secs);
 128     ExecuteJavascriptAndWaitForOk(
 129         base::StringPrintf("%s({video: true}, 'myStreamName');",
 130                            kGetUserMediaAndGetStreamUp));
 131
 132     // Now the stream is up and running, start collecting traces.
 133     StartTracing();
 134
 135     ExecuteJavascriptAndWaitForOk(
 136         base::StringPrintf("waitAndStopVideoTrack(window['myStreamName'], %d);",
 137                            time_to_sample_secs));
 138
 139     // Wait until the page title changes to "OK". Do not sleep() here since that
 140     // would stop both this code and the browser underneath.
 141     StopTracing();
 142
 143     scoped_ptr<TraceAnalyzer> analyzer(CreateTraceAnalyzer());
 144     analyzer->AssociateBeginEndEvents();
 145     trace_analyzer::TraceEventVector events;
 146     DCHECK(measure_filter.size());
 147     analyzer->FindEvents(
 148         Query::EventNameIs(measure_filter),
 149         &events);
 150     ASSERT_GT(events.size(), 0u)
 151         << "Could not collect any samples during test, this is bad";
 152
 153     std::string duration_us;
 154     std::string interarrival_us;
 155     for (size_t i = 0; i != events.size(); ++i) {
 156       duration_us.append(
 157           base::StringPrintf("%d,", static_cast<int>(events[i]->duration)));
 158     }
 159
 160     for (size_t i = 1; i < events.size(); ++i) {
 161       // The event |timestamp| comes in ns, divide to get us like |duration|.
 162       interarrival_us.append(base::StringPrintf("%d,",
 163           static_cast<int>((events[i]->timestamp - events[i - 1]->timestamp) /
 164                            base::Time::kNanosecondsPerMicrosecond)));
 165     }
 166
 167     perf_test::PrintResultList(
 168         graph_name, "", "sample_duration", duration_us, "us", true);
 169
 170     perf_test::PrintResultList(
 171         graph_name, "", "interarrival_time", interarrival_us, "us", true);
 172   }
 173
 174   // Runs the JavaScript twoGetUserMedia with |constraints1| and |constraint2|.
 175   void RunTwoGetTwoGetUserMediaWithDifferentContraints(
 176       const std::string& constraints1,
 177       const std::string& constraints2,
 178       const std::string& expected_result) {
 179     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 180
 181     GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 182     NavigateToURL(shell(), url);
 183
 184     std::string command = "twoGetUserMedia(" + constraints1 + ',' +
 185         constraints2 + ')';
 186
 187     EXPECT_EQ(expected_result, ExecuteJavascriptAndReturnResult(command));
 188   }
 189
 190   void GetInputDevices(std::vector<std::string>* audio_ids,
 191                        std::vector<std::string>* video_ids) {
 192     GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 193     NavigateToURL(shell(), url);
 194
 195     std::string devices_as_json = ExecuteJavascriptAndReturnResult(
 196         "getSources()");
 197     EXPECT_FALSE(devices_as_json.empty());
 198
 199     int error_code;
 200     std::string error_message;
 201     scoped_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
 202         devices_as_json, base::JSON_ALLOW_TRAILING_COMMAS, &error_code,
 203         &error_message);
 204
 205     ASSERT_TRUE(value.get() != NULL) << error_message;
 206     EXPECT_EQ(value->GetType(), base::Value::TYPE_LIST);
 207
 208     base::ListValue* values;
 209     ASSERT_TRUE(value->GetAsList(&values));
 210
 211     for (base::ListValue::iterator it = values->begin();
 212          it != values->end(); ++it) {
 213       const base::DictionaryValue* dict;
 214       std::string kind;
 215       std::string device_id;
 216       ASSERT_TRUE((*it)->GetAsDictionary(&dict));
 217       ASSERT_TRUE(dict->GetString("kind", &kind));
 218       ASSERT_TRUE(dict->GetString("id", &device_id));
 219       ASSERT_FALSE(device_id.empty());
 220       EXPECT_TRUE(kind == "audio" || kind == "video");
 221       if (kind == "audio") {
 222         audio_ids->push_back(device_id);
 223       } else if (kind == "video") {
 224         video_ids->push_back(device_id);
 225       }
 226     }
 227     ASSERT_FALSE(audio_ids->empty());
 228     ASSERT_FALSE(video_ids->empty());
 229   }
 230
 231  private:
 232   base::trace_event::TraceLog* trace_log_;
 233   scoped_refptr<base::RefCountedString> recorded_trace_data_;
 234   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 235 };
 236
 237 // These tests will all make a getUserMedia call with different constraints and
 238 // see that the success callback is called. If the error callback is called or
 239 // none of the callbacks are called the tests will simply time out and fail.
 240
 241 // Test fails under MSan, http://crbug.com/445745
 242 #if defined(MEMORY_SANITIZER)
 243 #define MAYBE_GetVideoStreamAndStop DISABLED_GetVideoStreamAndStop
 244 #else
 245 #define MAYBE_GetVideoStreamAndStop GetVideoStreamAndStop
 246 #endif
 247 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 248                        MAYBE_GetVideoStreamAndStop) {
 249   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 250
 251   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 252   NavigateToURL(shell(), url);
 253
 254   ExecuteJavascriptAndWaitForOk(
 255       base::StringPrintf("%s({video: true});", kGetUserMediaAndStop));
 256 }
 257
 258 // Test fails under MSan, http://crbug.com/445745
 259 #if defined(MEMORY_SANITIZER)
 260 #define MAYBE_RenderSameTrackMediastreamAndStop \
 261   DISABLED_RenderSameTrackMediastreamAndStop
 262 #else
 263 #define MAYBE_RenderSameTrackMediastreamAndStop \
 264   RenderSameTrackMediastreamAndStop
 265 #endif
 266 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 267                        MAYBE_RenderSameTrackMediastreamAndStop) {
 268   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 269
 270   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 271   NavigateToURL(shell(), url);
 272
 273   ExecuteJavascriptAndWaitForOk(
 274       base::StringPrintf("%s({video: true});",
 275                          kRenderSameTrackMediastreamAndStop));
 276 }
 277
 278 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 279                        RenderClonedMediastreamAndStop) {
 280   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 281
 282   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 283   NavigateToURL(shell(), url);
 284
 285
 286   ExecuteJavascriptAndWaitForOk(
 287       base::StringPrintf("%s({video: true});",
 288                          kRenderClonedMediastreamAndStop));
 289 }
 290
 291 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 292                        kRenderClonedTrackMediastreamAndStop) {
 293   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 294
 295   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 296   NavigateToURL(shell(), url);
 297
 298   ExecuteJavascriptAndWaitForOk(
 299       base::StringPrintf("%s({video: true});",
 300                          kRenderClonedTrackMediastreamAndStop));
 301 }
 302
 303 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 304                        kRenderDuplicatedMediastreamAndStop) {
 305   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 306
 307   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 308   NavigateToURL(shell(), url);
 309
 310   ExecuteJavascriptAndWaitForOk(
 311       base::StringPrintf("%s({video: true});",
 312                           kRenderDuplicatedMediastreamAndStop));
 313 }
 314
 315 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 316                        GetAudioAndVideoStreamAndStop) {
 317   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 318
 319   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 320   NavigateToURL(shell(), url);
 321
 322   ExecuteJavascriptAndWaitForOk(base::StringPrintf(
 323       "%s({video: true, audio: true});", kGetUserMediaAndStop));
 324 }
 325
 326 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 327                        GetAudioAndVideoStreamAndClone) {
 328   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 329
 330   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 331   NavigateToURL(shell(), url);
 332
 333   ExecuteJavascriptAndWaitForOk("getUserMediaAndClone();");
 334 }
 335
 336 // Test fails under Android, http://crbug.com/524388
 337 // Test fails under MSan
 338 // Flaky everywhere else: http://crbug.com/523152
 339 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 340                        DISABLED_RenderVideoTrackInMultipleTagsAndPause) {
 341   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 342
 343   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 344   NavigateToURL(shell(), url);
 345
 346   ExecuteJavascriptAndWaitForOk("getUserMediaAndRenderInSeveralVideoTags();");
 347 }
 348
 349 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 350                        GetUserMediaWithMandatorySourceID) {
 351   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 352
 353   std::vector<std::string> audio_ids;
 354   std::vector<std::string> video_ids;
 355   GetInputDevices(&audio_ids, &video_ids);
 356
 357   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 358
 359   // Test all combinations of mandatory sourceID;
 360   for (std::vector<std::string>::const_iterator video_it = video_ids.begin();
 361        video_it != video_ids.end(); ++video_it) {
 362     for (std::vector<std::string>::const_iterator audio_it = audio_ids.begin();
 363          audio_it != audio_ids.end(); ++audio_it) {
 364       NavigateToURL(shell(), url);
 365       EXPECT_EQ(kOK, ExecuteJavascriptAndReturnResult(
 366           GenerateGetUserMediaWithMandatorySourceID(
 367               kGetUserMediaAndStop,
 368               *audio_it,
 369               *video_it)));
 370     }
 371   }
 372 }
 373
 374 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 375                        GetUserMediaWithInvalidMandatorySourceID) {
 376   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 377
 378   std::vector<std::string> audio_ids;
 379   std::vector<std::string> video_ids;
 380   GetInputDevices(&audio_ids, &video_ids);
 381
 382   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 383
 384   // Test with invalid mandatory audio sourceID.
 385   NavigateToURL(shell(), url);
 386   EXPECT_EQ("DevicesNotFoundError", ExecuteJavascriptAndReturnResult(
 387       GenerateGetUserMediaWithMandatorySourceID(
 388           kGetUserMediaAndExpectFailure,
 389           "something invalid",
 390           video_ids[0])));
 391
 392   // Test with invalid mandatory video sourceID.
 393   EXPECT_EQ("DevicesNotFoundError", ExecuteJavascriptAndReturnResult(
 394       GenerateGetUserMediaWithMandatorySourceID(
 395           kGetUserMediaAndExpectFailure,
 396           audio_ids[0],
 397           "something invalid")));
 398
 399   // Test with empty mandatory audio sourceID.
 400   EXPECT_EQ("DevicesNotFoundError", ExecuteJavascriptAndReturnResult(
 401       GenerateGetUserMediaWithMandatorySourceID(
 402           kGetUserMediaAndExpectFailure,
 403           "",
 404           video_ids[0])));
 405 }
 406
 407 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 408                        GetUserMediaWithInvalidOptionalSourceID) {
 409   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 410
 411   std::vector<std::string> audio_ids;
 412   std::vector<std::string> video_ids;
 413   GetInputDevices(&audio_ids, &video_ids);
 414
 415   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 416
 417   // Test with invalid optional audio sourceID.
 418   NavigateToURL(shell(), url);
 419   EXPECT_EQ(kOK, ExecuteJavascriptAndReturnResult(
 420       GenerateGetUserMediaWithOptionalSourceID(
 421           kGetUserMediaAndStop,
 422           "something invalid",
 423           video_ids[0])));
 424
 425   // Test with invalid optional video sourceID.
 426   EXPECT_EQ(kOK, ExecuteJavascriptAndReturnResult(
 427       GenerateGetUserMediaWithOptionalSourceID(
 428           kGetUserMediaAndStop,
 429           audio_ids[0],
 430           "something invalid")));
 431
 432   // Test with empty optional audio sourceID.
 433   EXPECT_EQ(kOK, ExecuteJavascriptAndReturnResult(
 434       GenerateGetUserMediaWithOptionalSourceID(
 435           kGetUserMediaAndStop,
 436           "",
 437           video_ids[0])));
 438 }
 439
 440 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 441                        TwoGetUserMediaAndStop) {
 442   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 443
 444   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 445   NavigateToURL(shell(), url);
 446
 447   ExecuteJavascriptAndWaitForOk(
 448       "twoGetUserMediaAndStop({video: true, audio: true});");
 449 }
 450
 451 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 452                        TwoGetUserMediaWithEqualConstraints) {
 453   std::string constraints1 = "{video: true, audio: true}";
 454   const std::string& constraints2 = constraints1;
 455   std::string expected_result = "w=640:h=480-w=640:h=480";
 456
 457   RunTwoGetTwoGetUserMediaWithDifferentContraints(constraints1, constraints2,
 458                                                   expected_result);
 459 }
 460
 461 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 462                        TwoGetUserMediaWithSecondVideoCropped) {
 463   std::string constraints1 = "{video: true}";
 464   std::string constraints2 = "{video: {mandatory: {maxHeight: 360}}}";
 465   std::string expected_result = "w=640:h=480-w=640:h=360";
 466   RunTwoGetTwoGetUserMediaWithDifferentContraints(constraints1, constraints2,
 467                                                   expected_result);
 468 }
 469
 470 // Test fails under MSan, http://crbug.com/445745
 471 #if defined(MEMORY_SANITIZER)
 472 #define MAYBE_TwoGetUserMediaWithFirstHdSecondVga \
 473   DISABLED_TwoGetUserMediaWithFirstHdSecondVga
 474 #else
 475 #define MAYBE_TwoGetUserMediaWithFirstHdSecondVga \
 476   TwoGetUserMediaWithFirstHdSecondVga
 477 #endif
 478 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 479                        MAYBE_TwoGetUserMediaWithFirstHdSecondVga) {
 480   std::string constraints1 =
 481       "{video: {mandatory: {maxWidth:1280 , minWidth:1280 , maxHeight: 720,\
 482       minHeight: 720}}}";
 483   std::string constraints2 =
 484       "{video: {mandatory: {maxWidth:640 , maxHeight: 480}}}";
 485   std::string expected_result = "w=1280:h=720-w=640:h=480";
 486   RunTwoGetTwoGetUserMediaWithDifferentContraints(constraints1, constraints2,
 487                                                   expected_result);
 488 }
 489
 490 #if defined(OS_WIN)
 491 // Timing out on Winodws 7 bot: http://crbug.com/443294
 492 #define MAYBE_TwoGetUserMediaWithFirst1080pSecondVga\
 493     DISABLED_TwoGetUserMediaWithFirst1080pSecondVga
 494 #else
 495 #define MAYBE_TwoGetUserMediaWithFirst1080pSecondVga\
 496     TwoGetUserMediaWithFirst1080pSecondVga
 497 #endif
 498
 499 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 500                        MAYBE_TwoGetUserMediaWithFirst1080pSecondVga) {
 501   std::string constraints1 =
 502       "{video: {mandatory: {maxWidth:1920 , minWidth:1920 , maxHeight: 1080,\
 503       minHeight: 1080}}}";
 504   std::string constraints2 =
 505       "{video: {mandatory: {maxWidth:640 , maxHeight: 480}}}";
 506   std::string expected_result = "w=1920:h=1080-w=640:h=480";
 507   RunTwoGetTwoGetUserMediaWithDifferentContraints(constraints1, constraints2,
 508                                                   expected_result);
 509 }
 510
 511 // Test fails under MSan, http://crbug.com/445745
 512 #if defined(MEMORY_SANITIZER)
 513 #define MAYBE_TwoGetUserMediaAndVerifyFrameRate \
 514   DISABLED_TwoGetUserMediaAndVerifyFrameRate
 515 #else
 516 #define MAYBE_TwoGetUserMediaAndVerifyFrameRate \
 517   TwoGetUserMediaAndVerifyFrameRate
 518 #endif
 519 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 520                        MAYBE_TwoGetUserMediaAndVerifyFrameRate) {
 521   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 522
 523   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 524   NavigateToURL(shell(), url);
 525
 526   std::string constraints1 =
 527       "{video: {mandatory: {minWidth:640 , minHeight: 480, "
 528       "minFrameRate : 15, maxFrameRate : 15}}}";
 529   std::string constraints2 =
 530       "{video: {mandatory: {maxWidth:320 , maxHeight: 240,"
 531       "minFrameRate : 7, maxFrameRate : 7}}}";
 532
 533   std::string command = "twoGetUserMediaAndVerifyFrameRate(" +
 534       constraints1 + ',' + constraints2 + ", 15, 7)";
 535   ExecuteJavascriptAndWaitForOk(command);
 536 }
 537
 538 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 539                        GetUserMediaWithTooHighVideoConstraintsValues) {
 540   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 541
 542   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 543
 544   int large_value = 99999;
 545   std::string call = GenerateGetUserMediaCall(kGetUserMediaAndExpectFailure,
 546                                               large_value,
 547                                               large_value,
 548                                               large_value,
 549                                               large_value,
 550                                               large_value,
 551                                               large_value);
 552   NavigateToURL(shell(), url);
 553
 554   EXPECT_EQ("ConstraintNotSatisfiedError",
 555             ExecuteJavascriptAndReturnResult(call));
 556 }
 557
 558 // This test makes two getUserMedia requests, one with impossible constraints
 559 // that should trigger an error, and one with valid constraints. The test
 560 // verifies getUserMedia can succeed after being given impossible constraints.
 561 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 562                        TwoGetUserMediaAndCheckCallbackAfterFailure) {
 563   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 564
 565   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 566   NavigateToURL(shell(), url);
 567
 568   int large_value = 99999;
 569   const std::string gum_with_impossible_constraints =
 570     GenerateGetUserMediaCall(kGetUserMediaAndExpectFailure,
 571                              large_value,
 572                              large_value,
 573                              large_value,
 574                              large_value,
 575                              large_value,
 576                              large_value);
 577   const std::string gum_with_vga_constraints =
 578     GenerateGetUserMediaCall(kGetUserMediaAndAnalyseAndStop,
 579                              640, 640, 480, 480, 10, 30);
 580
 581   ASSERT_EQ("ConstraintNotSatisfiedError",
 582             ExecuteJavascriptAndReturnResult(gum_with_impossible_constraints));
 583
 584   ASSERT_EQ("w=640:h=480",
 585             ExecuteJavascriptAndReturnResult(gum_with_vga_constraints));
 586 }
 587
 588 // This test will make a simple getUserMedia page, verify that video is playing
 589 // in a simple local <video>, and for a couple of seconds, collect some
 590 // performance traces from VideoCaptureController colorspace conversion and
 591 // potential resizing.
 592 IN_PROC_BROWSER_TEST_F(
 593     WebRtcGetUserMediaBrowserTest,
 594     TraceVideoCaptureControllerPerformanceDuringGetUserMedia) {
 595   RunGetUserMediaAndCollectMeasures(
 596       10,
 597       "VideoCaptureDeviceClient::OnIncomingCapturedData",
 598       "VideoCaptureDeviceClient");
 599 }
 600
 601 // Test fails under MSan, http://crbug.com/445745
 602 #if defined(MEMORY_SANITIZER)
 603 #define MAYBE_TestGetUserMediaAspectRatio4To3 \
 604   DISABLED_TestGetUserMediaAspectRatio4To3
 605 #else
 606 #define MAYBE_TestGetUserMediaAspectRatio4To3 TestGetUserMediaAspectRatio4To3
 607 #endif
 608 // This test calls getUserMedia and checks for aspect ratio behavior.
 609 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 610                        MAYBE_TestGetUserMediaAspectRatio4To3) {
 611   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 612
 613   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 614
 615   std::string constraints_4_3 = GenerateGetUserMediaCall(
 616       kGetUserMediaAndAnalyseAndStop, 640, 640, 480, 480, 10, 30);
 617
 618   NavigateToURL(shell(), url);
 619   ASSERT_EQ("w=640:h=480",
 620             ExecuteJavascriptAndReturnResult(constraints_4_3));
 621 }
 622
 623 // Test fails under MSan, http://crbug.com/445745
 624 #if defined(MEMORY_SANITIZER)
 625 #define MAYBE_TestGetUserMediaAspectRatio16To9 \
 626   DISABLED_TestGetUserMediaAspectRatio16To9
 627 #else
 628 #define MAYBE_TestGetUserMediaAspectRatio16To9 TestGetUserMediaAspectRatio16To9
 629 #endif
 630 // This test calls getUserMedia and checks for aspect ratio behavior.
 631 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 632                        MAYBE_TestGetUserMediaAspectRatio16To9) {
 633   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 634
 635   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 636
 637   std::string constraints_16_9 = GenerateGetUserMediaCall(
 638       kGetUserMediaAndAnalyseAndStop, 640, 640, 360, 360, 10, 30);
 639
 640   NavigateToURL(shell(), url);
 641   ASSERT_EQ("w=640:h=360",
 642             ExecuteJavascriptAndReturnResult(constraints_16_9));
 643 }
 644
 645 // Test fails under MSan, http://crbug.com/445745
 646 #if defined(MEMORY_SANITIZER)
 647 #define MAYBE_TestGetUserMediaAspectRatio1To1 \
 648   DISABLED_TestGetUserMediaAspectRatio1To1
 649 #else
 650 #define MAYBE_TestGetUserMediaAspectRatio1To1 TestGetUserMediaAspectRatio1To1
 651 #endif
 652 // This test calls getUserMedia and checks for aspect ratio behavior.
 653 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 654                        MAYBE_TestGetUserMediaAspectRatio1To1) {
 655   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 656
 657   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 658
 659   std::string constraints_1_1 = GenerateGetUserMediaCall(
 660       kGetUserMediaAndAnalyseAndStop, 320, 320, 320, 320, 10, 30);
 661
 662   NavigateToURL(shell(), url);
 663   ASSERT_EQ("w=320:h=320",
 664             ExecuteJavascriptAndReturnResult(constraints_1_1));
 665 }
 666
 667 // This test calls getUserMedia in an iframe and immediately close the iframe
 668 // in the scope of the success callback.
 669 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 670                        AudioInIFrameAndCloseInSuccessCb) {
 671   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 672
 673   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 674   NavigateToURL(shell(), url);
 675
 676   std::string call =
 677       "getUserMediaInIframeAndCloseInSuccessCb({audio: true});";
 678   ExecuteJavascriptAndWaitForOk(call);
 679 }
 680
 681 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 682                        VideoInIFrameAndCloseInSuccessCb) {
 683   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 684
 685   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 686   NavigateToURL(shell(), url);
 687
 688   std::string call =
 689       "getUserMediaInIframeAndCloseInSuccessCb({video: true});";
 690   ExecuteJavascriptAndWaitForOk(call);
 691 }
 692
 693 // This test calls getUserMedia in an iframe and immediately close the iframe
 694 // in the scope of the failure callback.
 695 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 696                        VideoWithBadConstraintsInIFrameAndCloseInFailureCb) {
 697   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 698
 699   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 700
 701   int large_value = 99999;
 702   std::string call =
 703       GenerateGetUserMediaCall("getUserMediaInIframeAndCloseInFailureCb",
 704                                large_value,
 705                                large_value,
 706                                large_value,
 707                                large_value,
 708                                large_value,
 709                                large_value);
 710   NavigateToURL(shell(), url);
 711
 712   ExecuteJavascriptAndWaitForOk(call);
 713 }
 714
 715 IN_PROC_BROWSER_TEST_F(WebRtcGetUserMediaBrowserTest,
 716                        InvalidSourceIdInIFrameAndCloseInFailureCb) {
 717   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 718
 719   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 720
 721   std::string call =
 722       GenerateGetUserMediaWithMandatorySourceID(
 723           "getUserMediaInIframeAndCloseInFailureCb", "invalid", "invalid");
 724   NavigateToURL(shell(), url);
 725
 726   ExecuteJavascriptAndWaitForOk(call);
 727 }
 728
 729 namespace {
 730
 731 struct UserMediaSizes {
 732   int min_width;
 733   int max_width;
 734   int min_height;
 735   int max_height;
 736   int min_frame_rate;
 737   int max_frame_rate;
 738 };
 739
 740 }  // namespace
 741
 742 class WebRtcConstraintsBrowserTest
 743     : public WebRtcContentBrowserTest,
 744       public testing::WithParamInterface<UserMediaSizes> {
 745  public:
 746   WebRtcConstraintsBrowserTest() : user_media_(GetParam()) {}
 747   const UserMediaSizes& user_media() const { return user_media_; }
 748
 749  private:
 750   UserMediaSizes user_media_;
 751 };
 752
 753 // Test fails under MSan, http://crbug.com/445745
 754 #if defined(MEMORY_SANITIZER)
 755 #define MAYBE_GetUserMediaConstraints DISABLED_GetUserMediaConstraints
 756 #else
 757 #define MAYBE_GetUserMediaConstraints GetUserMediaConstraints
 758 #endif
 759 // This test calls getUserMedia in sequence with different constraints.
 760 IN_PROC_BROWSER_TEST_P(WebRtcConstraintsBrowserTest,
 761                        MAYBE_GetUserMediaConstraints) {
 762   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 763
 764   GURL url(embedded_test_server()->GetURL("/media/getusermedia.html"));
 765
 766   std::string call = GenerateGetUserMediaCall(kGetUserMediaAndStop,
 767                                               user_media().min_width,
 768                                               user_media().max_width,
 769                                               user_media().min_height,
 770                                               user_media().max_height,
 771                                               user_media().min_frame_rate,
 772                                               user_media().max_frame_rate);
 773   DVLOG(1) << "Calling getUserMedia: " << call;
 774   NavigateToURL(shell(), url);
 775   ExecuteJavascriptAndWaitForOk(call);
 776 }
 777
 778 static const UserMediaSizes kAllUserMediaSizes[] = {
 779     {320, 320, 180, 180, 10, 30},
 780     {320, 320, 240, 240, 10, 30},
 781     {640, 640, 360, 360, 10, 30},
 782     {640, 640, 480, 480, 10, 30},
 783     {960, 960, 720, 720, 10, 30},
 784     {1280, 1280, 720, 720, 10, 30}};
 785
 786 INSTANTIATE_TEST_CASE_P(UserMedia,
 787                         WebRtcConstraintsBrowserTest,
 788                         testing::ValuesIn(kAllUserMediaSizes));
 789
 790 }  // namespace content