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