duplicate the webrtc content_browser tests and browser tests with --enable-audio-track-processing on

chrome/browser/media/chrome_webrtc_audio_quality_browsertest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <ctime>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
@@ skipping 71 matching lines @@
 //    devices. Tick 'show disabled devices'.
 // 3. You should see a 'stero mix' device - this is what your speakers output.
 //    Right click > Properties.
 // 4. In the Listen tab for the mix device, check the 'listen to this device'
 //    checkbox. Ensure the mix device is the default recording device.
 // 5. Launch chrome and try playing a video with sound. You should see
 //    in the volume meter for the mix device. Configure the mix device to have
 //    50 / 100 in level. Also go into the playback tab, right-click Speakers,
 //    and set that level to 50 / 100. Otherwise you will get distortion in
 //    the recording.
-class WebRtcAudioQualityBrowserTest : public WebRtcTestBase {
+class WebRtcAudioQualityBrowserTest : public WebRtcTestBase,
+                                      public testing::WithParamInterface<bool> {
  public:
+  WebRtcAudioQualityBrowserTest() : enable_audio_track_processing_(GetParam()) {

[phoglund_chromium, 2014/03/13 09:04:49]

It's not necessary to store this as a member variable; just do this in
SetUpCommandLine:

bool enable_audio_track_processing = GetParam();
if (enable_audio_track_processing_)
  command_line->AppendSwitch(switches::kEnableAudioTrackProcessing);

and get rid of the constructor.

[no longer working on chromium, 2014/03/13 09:58:08]

Done.

+  }
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     PeerConnectionServerRunner::KillAllPeerConnectionServersOnCurrentSystem();
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // This test expects real device handling and requires a real webcam / audio
     // device; it will not work with fake devices.
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeDeviceForMediaStream));
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeUIForMediaStream));
+    if (enable_audio_track_processing_) {
+      command_line->AppendSwitch(switches::kEnableAudioTrackProcessing);
+    }
   }
 
   bool HasAllRequiredResources() {
     base::FilePath reference_file = GetTestDataDir().Append(kReferenceFile);
     if (!base::PathExists(reference_file)) {
       LOG(ERROR) << "Cannot find the reference file to be used for audio "
           << "quality comparison: " << reference_file.value();
       return false;
     }
     return true;
@@ skipping 24 matching lines @@
   base::FilePath CreateTemporaryWaveFile() {
     base::FilePath filename;
     EXPECT_TRUE(base::CreateTemporaryFile(&filename));
     base::FilePath wav_filename =
         filename.AddExtension(FILE_PATH_LITERAL(".wav"));
     EXPECT_TRUE(base::Move(filename, wav_filename));
     return wav_filename;
   }
 
   PeerConnectionServerRunner peerconnection_server_;
+  bool enable_audio_track_processing_;
 };
 
 class AudioRecorder {
  public:
   AudioRecorder(): recording_application_(base::kNullProcessHandle) {}
   ~AudioRecorder() {}
 
   // Starts the recording program for the specified duration. Returns true
   // on success.
   bool StartRecording(int duration_sec, const base::FilePath& output_file,
@@ skipping 194 matching lines @@
   // There are two tab-separated numbers on the format x.xxx, e.g. 5 chars each.
   std::size_t first_number_pos = anchor_pos + result_anchor.length();
   *raw_mos = result.substr(first_number_pos, 5);
   EXPECT_TRUE(CanParseAsFloat(*raw_mos)) << "Failed to parse raw MOS number.";
   *mos_lqo = result.substr(first_number_pos + 5 + 1, 5);
   EXPECT_TRUE(CanParseAsFloat(*mos_lqo)) << "Failed to parse MOS LQO number.";
 
   return true;
 }
 
+static const bool kRunTestsWithFlag[] = { false, true };
+INSTANTIATE_TEST_CASE_P(WebRtcAudioQualityBrowserTests,
+                        WebRtcAudioQualityBrowserTest,
+                        testing::ValuesIn(kRunTestsWithFlag));
+
 // Should be enabled for Linux, but is flaky. http://crbug.com/340197.
 #if defined(OS_WIN)
 // Only implemented on Linux and Windows for now.
 #define MAYBE_MANUAL_TestAudioQuality MANUAL_TestAudioQuality
 #else
 #define MAYBE_MANUAL_TestAudioQuality DISABLED_MANUAL_TestAudioQuality
 #endif
 
-IN_PROC_BROWSER_TEST_F(WebRtcAudioQualityBrowserTest,
+IN_PROC_BROWSER_TEST_P(WebRtcAudioQualityBrowserTest,
                        MAYBE_MANUAL_TestAudioQuality) {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     // It would take work to implement this on XP; not prioritized right now.
     LOG(ERROR) << "This test is not implemented for Windows XP.";
     return;
   }
 #endif
   ASSERT_TRUE(HasAllRequiredResources());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
@@ skipping 58 matching lines @@
                       &raw_mos, &mos_lqo));
 
   perf_test::PrintResult("audio_pesq", "", "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult("audio_pesq", "", "mos_lqo", mos_lqo, "score", true);
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
   EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 
   ASSERT_TRUE(peerconnection_server_.Stop());
 }