content/browser/media/webrtc_browsertest.cc

   1 // Copyright (c) 2012 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/file_util.h"
   7 #include "base/process/process_handle.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/threading/platform_thread.h"
  11 #include "base/values.h"
  12 #include "content/browser/media/webrtc_internals.h"
  13 #include "content/browser/web_contents/web_contents_impl.h"
  14 #include "content/public/common/content_switches.h"
  15 #include "content/public/test/browser_test_utils.h"
  16 #include "content/public/test/content_browser_test_utils.h"
  17 #include "content/public/test/test_utils.h"
  18 #include "content/shell/browser/shell.h"
  19 #include "content/test/webrtc_content_browsertest_base.h"
  20 #include "media/audio/audio_manager.h"
  21 #include "media/base/media_switches.h"
  22 #include "net/test/embedded_test_server/embedded_test_server.h"
  23
  24 #if defined(OS_WIN)
  25 #include "base/win/windows_version.h"
  26 #endif
  27
  28 namespace {
  29
  30 #if defined (OS_ANDROID) || defined(THREAD_SANITIZER)
  31 // Just do the bare minimum of audio checking on Android and under TSAN since
  32 // it's a bit sensitive to device performance.
  33 const char kUseLenientAudioChecking[] = "true";
  34 #else
  35 const char kUseLenientAudioChecking[] = "false";
  36 #endif
  37
  38 const int kExpectedConsumerId = 0;
  39
  40 // Get the ID for the render process host when there should only be one.
  41 bool GetRenderProcessHostId(base::ProcessId* id) {
  42   content::RenderProcessHost::iterator it(
  43       content::RenderProcessHost::AllHostsIterator());
  44   *id = base::GetProcId(it.GetCurrentValue()->GetHandle());
  45   EXPECT_NE(base::kNullProcessId, *id);
  46   if (*id == base::kNullProcessId)
  47     return false;
  48   it.Advance();
  49   EXPECT_TRUE(it.IsAtEnd());
  50   return it.IsAtEnd();
  51 }
  52
  53 }  // namespace
  54
  55 namespace content {
  56
  57 class WebRtcBrowserTest : public WebRtcContentBrowserTest,
  58                           public testing::WithParamInterface<bool> {
  59  public:
  60   WebRtcBrowserTest() {}
  61   virtual ~WebRtcBrowserTest() {}
  62
  63   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  64     WebRtcContentBrowserTest::SetUpCommandLine(command_line);
  65
  66     bool enable_audio_track_processing = GetParam();
  67     if (!enable_audio_track_processing)
  68       command_line->AppendSwitch(switches::kDisableAudioTrackProcessing);
  69   }
  70
  71   // Convenience function since most peerconnection-call.html tests just load
  72   // the page, kick off some javascript and wait for the title to change to OK.
  73   void MakeTypicalPeerConnectionCall(const std::string& javascript) {
  74     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
  75
  76     GURL url(embedded_test_server()->GetURL("/media/peerconnection-call.html"));
  77     NavigateToURL(shell(), url);
  78
  79     DisableOpusIfOnAndroid();
  80     ExecuteJavascriptAndWaitForOk(javascript);
  81   }
  82
  83   // Convenience method for making calls that detect if audio os playing (which
  84   // has some special prerequisites, such that there needs to be an audio output
  85   // device on the executing machine).
  86   void MakeAudioDetectingPeerConnectionCall(const std::string& javascript) {
  87     if (!media::AudioManager::Get()->HasAudioOutputDevices()) {
  88       // Bots with no output devices will force the audio code into a state
  89       // where it doesn't manage to set either the low or high latency path.
  90       // This test will compute useless values in that case, so skip running on
  91       // such bots (see crbug.com/326338).
  92       LOG(INFO) << "Missing output devices: skipping test...";
  93       return;
  94     }
  95
  96     ASSERT_TRUE(CommandLine::ForCurrentProcess()->HasSwitch(
  97         switches::kUseFakeDeviceForMediaStream))
  98             << "Must run with fake devices since the test will explicitly look "
  99             << "for the fake device signal.";
 100
 101     MakeTypicalPeerConnectionCall(javascript);
 102   }
 103
 104   void DisableOpusIfOnAndroid() {
 105 #if defined(OS_ANDROID)
 106     // Always force iSAC 16K on Android for now (Opus is broken).
 107     EXPECT_EQ("isac-forced",
 108               ExecuteJavascriptAndReturnResult("forceIsac16KInSdp();"));
 109 #endif
 110   }
 111 };
 112
 113 static const bool kRunTestsWithFlag[] = { false, true };
 114 INSTANTIATE_TEST_CASE_P(WebRtcBrowserTests,
 115                         WebRtcBrowserTest,
 116                         testing::ValuesIn(kRunTestsWithFlag));
 117
 118 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 119 // Timing out on ARM linux bot: http://crbug.com/238490
 120 #define MAYBE_CanSetupDefaultVideoCall DISABLED_CanSetupDefaultVideoCall
 121 #else
 122 #define MAYBE_CanSetupDefaultVideoCall CanSetupDefaultVideoCall
 123 #endif
 124
 125 // These tests will make a complete PeerConnection-based call and verify that
 126 // video is playing for the call.
 127 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CanSetupDefaultVideoCall) {
 128   MakeTypicalPeerConnectionCall(
 129       "callAndExpectResolution({video: true}, 640, 480);");
 130 }
 131
 132 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, CanSetupVideoCallWith1To1AspecRatio) {
 133   const std::string javascript =
 134       "callAndExpectResolution({video: {mandatory: {minWidth: 320,"
 135       " maxWidth: 320, minHeight: 320, maxHeight: 320}}}, 320, 320);";
 136   MakeTypicalPeerConnectionCall(javascript);
 137 }
 138
 139 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 140                        CanSetupVideoCallWith16To9AspecRatio) {
 141   const std::string javascript =
 142       "callAndExpectResolution({video: {mandatory: {minWidth: 640,"
 143       " maxWidth: 640, minAspectRatio: 1.777}}}, 640, 360);";
 144   MakeTypicalPeerConnectionCall(javascript);
 145 }
 146
 147 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 148                        CanSetupVideoCallWith4To3AspecRatio) {
 149   const std::string javascript =
 150       "callAndExpectResolution({video: {mandatory: {minWidth: 960,"
 151       "maxAspectRatio: 1.333}}}, 960, 720);";
 152   MakeTypicalPeerConnectionCall(javascript);
 153 }
 154
 155 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 156 // Timing out on ARM linux, see http://crbug.com/240376
 157 #define MAYBE_CanSetupAudioAndVideoCall DISABLED_CanSetupAudioAndVideoCall
 158 #else
 159 #define MAYBE_CanSetupAudioAndVideoCall CanSetupAudioAndVideoCall
 160 #endif
 161
 162 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CanSetupAudioAndVideoCall) {
 163   MakeTypicalPeerConnectionCall("call({video: true, audio: true});");
 164 }
 165
 166 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MANUAL_CanSetupCallAndSendDtmf) {
 167   MakeTypicalPeerConnectionCall("callAndSendDtmf(\'123,abc\');");
 168 }
 169
 170 // TODO(phoglund): this test fails because the peer connection state will be
 171 // stable in the second negotiation round rather than have-local-offer.
 172 // http://crbug.com/293125.
 173 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 174                        DISABLED_CanMakeEmptyCallThenAddStreamsAndRenegotiate) {
 175   const char* kJavascript =
 176       "callEmptyThenAddOneStreamAndRenegotiate({video: true, audio: true});";
 177   MakeTypicalPeerConnectionCall(kJavascript);
 178 }
 179
 180 // Below 2 test will make a complete PeerConnection-based call between pc1 and
 181 // pc2, and then use the remote stream to setup a call between pc3 and pc4, and
 182 // then verify that video is received on pc3 and pc4.
 183 // The stream sent from pc3 to pc4 is the stream received on pc1.
 184 // The stream sent from pc4 to pc3 is cloned from stream the stream received
 185 // on pc2.
 186 // Flaky on win xp. http://crbug.com/304775
 187 #if defined(OS_WIN)
 188 #define MAYBE_CanForwardRemoteStream DISABLED_CanForwardRemoteStream
 189 #define MAYBE_CanForwardRemoteStream720p DISABLED_CanForwardRemoteStream720p
 190 #else
 191 #define MAYBE_CanForwardRemoteStream CanForwardRemoteStream
 192 // Flaky on TSAN v2. http://crbug.com/373637
 193 #if defined(THREAD_SANITIZER)
 194 #define MAYBE_CanForwardRemoteStream720p DISABLED_CanForwardRemoteStream720p
 195 #else
 196 #define MAYBE_CanForwardRemoteStream720p CanForwardRemoteStream720p
 197 #endif
 198 #endif
 199 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CanForwardRemoteStream) {
 200 #if defined (OS_ANDROID)
 201   // This test fails on Nexus 5 devices.
 202   // TODO(henrika): see http://crbug.com/362437 and http://crbug.com/359389
 203   // for details.
 204   CommandLine::ForCurrentProcess()->AppendSwitch(
 205       switches::kDisableWebRtcHWDecoding);
 206 #endif
 207   MakeTypicalPeerConnectionCall(
 208       "callAndForwardRemoteStream({video: true, audio: false});");
 209 }
 210
 211 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CanForwardRemoteStream720p) {
 212 #if defined (OS_ANDROID)
 213   // This test fails on Nexus 5 devices.
 214   // TODO(henrika): see http://crbug.com/362437 and http://crbug.com/359389
 215   // for details.
 216   CommandLine::ForCurrentProcess()->AppendSwitch(
 217       switches::kDisableWebRtcHWDecoding);
 218 #endif
 219   const std::string javascript = GenerateGetUserMediaCall(
 220       "callAndForwardRemoteStream", 1280, 1280, 720, 720, 10, 30);
 221   MakeTypicalPeerConnectionCall(javascript);
 222 }
 223
 224 // This test will make a complete PeerConnection-based call but remove the
 225 // MSID and bundle attribute from the initial offer to verify that
 226 // video is playing for the call even if the initiating client don't support
 227 // MSID. http://tools.ietf.org/html/draft-alvestrand-rtcweb-msid-02
 228 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 229 // Timing out on ARM linux, see http://crbug.com/240373
 230 #define MAYBE_CanSetupAudioAndVideoCallWithoutMsidAndBundle\
 231         DISABLED_CanSetupAudioAndVideoCallWithoutMsidAndBundle
 232 #else
 233 #define MAYBE_CanSetupAudioAndVideoCallWithoutMsidAndBundle\
 234         CanSetupAudioAndVideoCallWithoutMsidAndBundle
 235 #endif
 236 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 237                        MAYBE_CanSetupAudioAndVideoCallWithoutMsidAndBundle) {
 238   MakeTypicalPeerConnectionCall("callWithoutMsidAndBundle();");
 239 }
 240
 241 // This test will modify the SDP offer to an unsupported codec, which should
 242 // cause SetLocalDescription to fail.
 243 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, NegotiateUnsupportedVideoCodec) {
 244   MakeTypicalPeerConnectionCall("negotiateUnsupportedVideoCodec();");
 245 }
 246
 247 // This test will modify the SDP offer to use no encryption, which should
 248 // cause SetLocalDescription to fail.
 249 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, NegotiateNonCryptoCall) {
 250   MakeTypicalPeerConnectionCall("negotiateNonCryptoCall();");
 251 }
 252
 253 // This test can negotiate an SDP offer that includes a b=AS:xx to control
 254 // the bandwidth for audio and video
 255 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, NegotiateOfferWithBLine) {
 256   MakeTypicalPeerConnectionCall("negotiateOfferWithBLine();");
 257 }
 258
 259 // This test will make a complete PeerConnection-based call using legacy SDP
 260 // settings: GIce, external SDES, and no BUNDLE.
 261 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 262 // Timing out on ARM linux, see http://crbug.com/240373
 263 #define MAYBE_CanSetupLegacyCall DISABLED_CanSetupLegacyCall
 264 #else
 265 #define MAYBE_CanSetupLegacyCall CanSetupLegacyCall
 266 #endif
 267
 268 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CanSetupLegacyCall) {
 269   MakeTypicalPeerConnectionCall("callWithLegacySdp();");
 270 }
 271
 272 // This test will make a PeerConnection-based call and test an unreliable text
 273 // dataChannel.
 274 // TODO(mallinath) - Remove this test after rtp based data channel is disabled.
 275 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, CallWithDataOnly) {
 276   MakeTypicalPeerConnectionCall("callWithDataOnly();");
 277 }
 278
 279 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, CallWithSctpDataOnly) {
 280   MakeTypicalPeerConnectionCall("callWithSctpDataOnly();");
 281 }
 282
 283 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 284 // Timing out on ARM linux bot: http://crbug.com/238490
 285 #define MAYBE_CallWithDataAndMedia DISABLED_CallWithDataAndMedia
 286 #else
 287 #define MAYBE_CallWithDataAndMedia CallWithDataAndMedia
 288 #endif
 289
 290 // This test will make a PeerConnection-based call and test an unreliable text
 291 // dataChannel and audio and video tracks.
 292 // TODO(mallinath) - Remove this test after rtp based data channel is disabled.
 293 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, DISABLED_CallWithDataAndMedia) {
 294   MakeTypicalPeerConnectionCall("callWithDataAndMedia();");
 295 }
 296
 297
 298 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 299 // Timing out on ARM linux bot: http://crbug.com/238490
 300 #define MAYBE_CallWithSctpDataAndMedia DISABLED_CallWithSctpDataAndMedia
 301 #else
 302 #define MAYBE_CallWithSctpDataAndMedia CallWithSctpDataAndMedia
 303 #endif
 304
 305 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 306                        MAYBE_CallWithSctpDataAndMedia) {
 307   MakeTypicalPeerConnectionCall("callWithSctpDataAndMedia();");
 308 }
 309
 310 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 311 // Timing out on ARM linux bot: http://crbug.com/238490
 312 #define MAYBE_CallWithDataAndLaterAddMedia DISABLED_CallWithDataAndLaterAddMedia
 313 #else
 314 // Temporarily disable the test on all platforms. http://crbug.com/293252
 315 #define MAYBE_CallWithDataAndLaterAddMedia DISABLED_CallWithDataAndLaterAddMedia
 316 #endif
 317
 318 // This test will make a PeerConnection-based call and test an unreliable text
 319 // dataChannel and later add an audio and video track.
 320 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CallWithDataAndLaterAddMedia) {
 321   MakeTypicalPeerConnectionCall("callWithDataAndLaterAddMedia();");
 322 }
 323
 324 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 325 // Timing out on ARM linux bot: http://crbug.com/238490
 326 #define MAYBE_CallWithNewVideoMediaStream DISABLED_CallWithNewVideoMediaStream
 327 #else
 328 #define MAYBE_CallWithNewVideoMediaStream CallWithNewVideoMediaStream
 329 #endif
 330
 331 // This test will make a PeerConnection-based call and send a new Video
 332 // MediaStream that has been created based on a MediaStream created with
 333 // getUserMedia.
 334 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CallWithNewVideoMediaStream) {
 335   MakeTypicalPeerConnectionCall("callWithNewVideoMediaStream();");
 336 }
 337
 338 // This test will make a PeerConnection-based call and send a new Video
 339 // MediaStream that has been created based on a MediaStream created with
 340 // getUserMedia. When video is flowing, the VideoTrack is removed and an
 341 // AudioTrack is added instead.
 342 // TODO(phoglund): This test is manual since not all buildbots has an audio
 343 // input.
 344 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MANUAL_CallAndModifyStream) {
 345   MakeTypicalPeerConnectionCall(
 346       "callWithNewVideoMediaStreamLaterSwitchToAudio();");
 347 }
 348
 349 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, AddTwoMediaStreamsToOnePC) {
 350   MakeTypicalPeerConnectionCall("addTwoMediaStreamsToOneConnection();");
 351 }
 352
 353 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 354                        EstablishAudioVideoCallAndEnsureAudioIsPlaying) {
 355   MakeAudioDetectingPeerConnectionCall(base::StringPrintf(
 356       "callAndEnsureAudioIsPlaying(%s, {audio:true, video:true});",
 357       kUseLenientAudioChecking));
 358 }
 359
 360 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 361                        EstablishAudioOnlyCallAndEnsureAudioIsPlaying) {
 362   MakeAudioDetectingPeerConnectionCall(base::StringPrintf(
 363       "callAndEnsureAudioIsPlaying(%s, {audio:true});",
 364       kUseLenientAudioChecking));
 365 }
 366
 367 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 368                        EstablishAudioVideoCallAndVerifyMutingWorks) {
 369   MakeAudioDetectingPeerConnectionCall(base::StringPrintf(
 370       "callAndEnsureAudioTrackMutingWorks(%s);", kUseLenientAudioChecking));
 371 }
 372
 373 // Flaky on TSAN v2: http://crbug.com/373637
 374 #if defined(THREAD_SANITIZER)
 375 #define MAYBE_EstablishAudioVideoCallAndVerifyUnmutingWorks\
 376         DISABLED_EstablishAudioVideoCallAndVerifyUnmutingWorks
 377 #else
 378 #define MAYBE_EstablishAudioVideoCallAndVerifyUnmutingWorks\
 379         EstablishAudioVideoCallAndVerifyUnmutingWorks
 380 #endif
 381 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 382                        MAYBE_EstablishAudioVideoCallAndVerifyUnmutingWorks) {
 383   MakeAudioDetectingPeerConnectionCall(base::StringPrintf(
 384       "callAndEnsureAudioTrackUnmutingWorks(%s);", kUseLenientAudioChecking));
 385 }
 386
 387 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, CallAndVerifyVideoMutingWorks) {
 388   MakeTypicalPeerConnectionCall("callAndEnsureVideoTrackMutingWorks();");
 389 }
 390
 391 #if defined(OS_WIN)
 392 #define IntToStringType base::IntToString16
 393 #else
 394 #define IntToStringType base::IntToString
 395 #endif
 396
 397 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 398 // Timing out on ARM linux bot: http://crbug.com/238490
 399 #define MAYBE_CallWithAecDump DISABLED_CallWithAecDump
 400 #else
 401 #define MAYBE_CallWithAecDump CallWithAecDump
 402 #endif
 403
 404 // This tests will make a complete PeerConnection-based call, verify that
 405 // video is playing for the call, and verify that a non-empty AEC dump file
 406 // exists. The AEC dump is enabled through webrtc-internals. The HTML and
 407 // Javascript is bypassed since it would trigger a file picker dialog. Instead,
 408 // the dialog callback FileSelected() is invoked directly. In fact, there's
 409 // never a webrtc-internals page opened at all since that's not needed.
 410 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_CallWithAecDump) {
 411   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 412
 413   // We must navigate somewhere first so that the render process is created.
 414   NavigateToURL(shell(), GURL(""));
 415
 416   base::FilePath dump_file;
 417   ASSERT_TRUE(CreateTemporaryFile(&dump_file));
 418   base::DeleteFile(dump_file, false);
 419
 420   // This fakes the behavior of another open tab with webrtc-internals, and
 421   // enabling AEC dump in that tab.
 422   WebRTCInternals::GetInstance()->FileSelected(dump_file, -1, NULL);
 423
 424   GURL url(embedded_test_server()->GetURL("/media/peerconnection-call.html"));
 425   NavigateToURL(shell(), url);
 426   DisableOpusIfOnAndroid();
 427   ExecuteJavascriptAndWaitForOk("call({video: true, audio: true});");
 428
 429   EXPECT_FALSE(base::PathExists(dump_file));
 430
 431   // Add file extensions that we expect to be added. The dump name will be
 432   // <temporary path>.<render process id>.<consumer id>, for example
 433   // "/tmp/.com.google.Chrome.Z6UC3P.12345.0".
 434   base::ProcessId render_process_id = base::kNullProcessId;
 435   EXPECT_TRUE(GetRenderProcessHostId(&render_process_id));
 436   dump_file = dump_file.AddExtension(IntToStringType(render_process_id))
 437                        .AddExtension(IntToStringType(kExpectedConsumerId));
 438
 439   EXPECT_TRUE(base::PathExists(dump_file));
 440   int64 file_size = 0;
 441   EXPECT_TRUE(base::GetFileSize(dump_file, &file_size));
 442   EXPECT_GT(file_size, 0);
 443
 444   base::DeleteFile(dump_file, false);
 445 }
 446
 447 // TODO(grunell): Add test for multiple dumps when re-use of
 448 // MediaStreamAudioProcessor in AudioCapturer has been removed.
 449
 450 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 451 // Timing out on ARM linux bot: http://crbug.com/238490
 452 #define MAYBE_CallWithAecDumpEnabledThenDisabled DISABLED_CallWithAecDumpEnabledThenDisabled
 453 #else
 454 #define MAYBE_CallWithAecDumpEnabledThenDisabled CallWithAecDumpEnabledThenDisabled
 455 #endif
 456
 457 // As above, but enable and disable dump before starting a call. The file should
 458 // be created, but should be empty.
 459 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
 460                        MAYBE_CallWithAecDumpEnabledThenDisabled) {
 461   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 462
 463   // We must navigate somewhere first so that the render process is created.
 464   NavigateToURL(shell(), GURL(""));
 465
 466   base::FilePath dump_file;
 467   ASSERT_TRUE(CreateTemporaryFile(&dump_file));
 468   base::DeleteFile(dump_file, false);
 469
 470   // This fakes the behavior of another open tab with webrtc-internals, and
 471   // enabling AEC dump in that tab, then disabling it.
 472   WebRTCInternals::GetInstance()->FileSelected(dump_file, -1, NULL);
 473   WebRTCInternals::GetInstance()->DisableAecDump();
 474
 475   GURL url(embedded_test_server()->GetURL("/media/peerconnection-call.html"));
 476   NavigateToURL(shell(), url);
 477   DisableOpusIfOnAndroid();
 478   ExecuteJavascriptAndWaitForOk("call({video: true, audio: true});");
 479
 480   // Add file extensions that we expect to be added.
 481   base::ProcessId render_process_id = base::kNullProcessId;
 482   EXPECT_TRUE(GetRenderProcessHostId(&render_process_id));
 483   dump_file = dump_file.AddExtension(IntToStringType(render_process_id))
 484                        .AddExtension(IntToStringType(kExpectedConsumerId));
 485
 486   EXPECT_FALSE(base::PathExists(dump_file));
 487
 488   base::DeleteFile(dump_file, false);
 489 }
 490
 491 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
 492 // Timing out on ARM linux bot: http://crbug.com/238490
 493 #define MAYBE_TwoCallsWithAecDump DISABLED_TwoCallsWithAecDump
 494 #else
 495 #define MAYBE_TwoCallsWithAecDump TwoCallsWithAecDump
 496 #endif
 497
 498 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MAYBE_TwoCallsWithAecDump) {
 499   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 500
 501   // We must navigate somewhere first so that the render process is created.
 502   NavigateToURL(shell(), GURL(""));
 503
 504   // Create a second window.
 505   Shell* shell2 = CreateBrowser();
 506   NavigateToURL(shell2, GURL(""));
 507
 508   base::FilePath dump_file;
 509   ASSERT_TRUE(CreateTemporaryFile(&dump_file));
 510   base::DeleteFile(dump_file, false);
 511
 512   // This fakes the behavior of another open tab with webrtc-internals, and
 513   // enabling AEC dump in that tab.
 514   WebRTCInternals::GetInstance()->FileSelected(dump_file, -1, NULL);
 515
 516   GURL url(embedded_test_server()->GetURL("/media/peerconnection-call.html"));
 517
 518   NavigateToURL(shell(), url);
 519   NavigateToURL(shell2, url);
 520   ExecuteJavascriptAndWaitForOk("call({video: true, audio: true});");
 521   std::string result;
 522   EXPECT_TRUE(ExecuteScriptAndExtractString(
 523       shell2->web_contents(),
 524       "call({video: true, audio: true});",
 525       &result));
 526   ASSERT_STREQ("OK", result.c_str());
 527
 528   EXPECT_FALSE(base::PathExists(dump_file));
 529
 530   RenderProcessHost::iterator it =
 531       content::RenderProcessHost::AllHostsIterator();
 532   for (; !it.IsAtEnd(); it.Advance()) {
 533     base::ProcessId render_process_id =
 534         base::GetProcId(it.GetCurrentValue()->GetHandle());
 535     EXPECT_NE(base::kNullProcessId, render_process_id);
 536
 537     // Add file extensions that we expect to be added.
 538     base::FilePath unique_dump_file =
 539         dump_file.AddExtension(IntToStringType(render_process_id))
 540                  .AddExtension(IntToStringType(kExpectedConsumerId));
 541
 542     EXPECT_TRUE(base::PathExists(unique_dump_file));
 543     int64 file_size = 0;
 544     EXPECT_TRUE(base::GetFileSize(unique_dump_file, &file_size));
 545     EXPECT_GT(file_size, 0);
 546
 547     base::DeleteFile(unique_dump_file, false);
 548   }
 549 }
 550
 551 }  // namespace content