Make callers of CommandLine use it via the base:: namespace.

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/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 110 matching lines @@
 //    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 MAYBE_WebRtcAudioQualityBrowserTest : public WebRtcTestBase {
  public:
   MAYBE_WebRtcAudioQualityBrowserTest() {}
   void SetUpInProcessBrowserTestFixture() override {
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
-  void SetUpCommandLine(CommandLine* command_line) override {
+  void SetUpCommandLine(base::CommandLine* command_line) override {
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeUIForMediaStream));
 
     // The WebAudio-based tests don't care what devices are available to
     // getUserMedia, and the getUserMedia-based tests will play back a file
     // through the fake device using using --use-file-for-fake-audio-capture.
     command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
   }
 
   void ConfigureFakeDeviceToPlayFile(const base::FilePath& wav_file_path) {
-    CommandLine::ForCurrentProcess()->AppendSwitchPath(
+    base::CommandLine::ForCurrentProcess()->AppendSwitchPath(
         switches::kUseFileForFakeAudioCapture, wav_file_path);
   }
 
   void AddAudioFileToWebAudio(const std::string& input_file_relative_url,
                               content::WebContents* tab_contents) {
     // This calls into webaudio.js.
     EXPECT_EQ("ok-added", ExecuteJavascript(
         "addAudioFile('" + input_file_relative_url + "')", tab_contents));
   }
 
@@ skipping 32 matching lines @@
   // on success. We record in 44.1 kHz 16-bit format unless |record_cd| is
   // false, in which case we record in 48 kHz 16-bit format. We record in stereo
   // unless |mono| is true.
   // TODO(phoglund): make win and mac also support the record_cd parameter. Or,
   // even better, make everybody use the CD format rather than DAT.
   bool StartRecording(int duration_sec, const base::FilePath& output_file,
                       bool mono, bool record_cd) {
     EXPECT_FALSE(recording_application_.IsValid())
         << "Tried to record, but is already recording.";
 
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
 #if defined(OS_WIN)
     // This disable is required to run SoundRecorder.exe on 64-bit Windows
     // from a 32-bit binary. We need to load the wow64 disable function from
     // the DLL since it doesn't exist on Windows XP.
     // TODO(phoglund): find some cleaner solution than using SoundRecorder.exe.
     base::ScopedNativeLibrary kernel32_lib(base::FilePath(L"kernel32"));
     if (kernel32_lib.is_valid()) {
       typedef BOOL (WINAPI* Wow64DisableWow64FSRedirection)(PVOID*);
       Wow64DisableWow64FSRedirection wow_64_disable_wow_64_fs_redirection;
       wow_64_disable_wow_64_fs_redirection =
@@ skipping 60 matching lines @@
     recording_application_.WaitForExit(&exit_code);
     return exit_code == 0;
   }
  private:
   base::Process recording_application_;
 };
 
 bool ForceMicrophoneVolumeTo100Percent() {
 #if defined(OS_WIN)
   // Note: the force binary isn't in tools since it's one of our own.
-  CommandLine command_line(test::GetReferenceFilesDir().Append(
+  base::CommandLine command_line(test::GetReferenceFilesDir().Append(
       FILE_PATH_LITERAL("force_mic_volume_max.exe")));
   DVLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
 #elif defined(OS_MACOSX)
-  CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("osascript")));
+  base::CommandLine command_line(
+      base::FilePath(FILE_PATH_LITERAL("osascript")));
   command_line.AppendArg("-e");
   command_line.AppendArg("set volume input volume 100");
   command_line.AppendArg("-e");
   command_line.AppendArg("set volume output volume 100");
 
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
 #else
   // Just force the volume of, say the first 5 devices. A machine will rarely
   // have more input sources than that. This is way easier than finding the
   // input device we happen to be using.
   for (int device_index = 0; device_index < 5; ++device_index) {
     std::string result;
     const std::string kHundredPercentVolume = "65536";
-    CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("pacmd")));
+    base::CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("pacmd")));
     command_line.AppendArg("set-source-volume");
     command_line.AppendArg(base::StringPrintf("%d", device_index));
     command_line.AppendArg(kHundredPercentVolume);
     DVLOG(0) << "Running " << command_line.GetCommandLineString();
     if (!base::GetAppOutput(command_line, &result)) {
       LOG(ERROR) << "Failed to set source volume: output was " << result;
       return false;
     }
   }
 #endif
   return true;
 }
 
 // Sox is the "Swiss army knife" of audio processing. We mainly use it for
 // silence trimming. See http://sox.sourceforge.net.
-CommandLine MakeSoxCommandLine() {
+base::CommandLine MakeSoxCommandLine() {
 #if defined(OS_WIN)
   base::FilePath sox_path = test::GetReferenceFilesDir().Append(
       FILE_PATH_LITERAL("tools/sox.exe"));
   if (!base::PathExists(sox_path)) {
     LOG(ERROR) << "Missing sox.exe binary in " << sox_path.value()
                << "; you may have to provide this binary yourself.";
-    return CommandLine(CommandLine::NO_PROGRAM);
+    return base::CommandLine(base::CommandLine::NO_PROGRAM);
   }
-  CommandLine command_line(sox_path);
+  base::CommandLine command_line(sox_path);
 #else
-  CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("sox")));
+  base::CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("sox")));
 #endif
   return command_line;
 }
 
 // Removes silence from beginning and end of the |input_audio_file| and writes
 // the result to the |output_audio_file|. Returns true on success.
 bool RemoveSilence(const base::FilePath& input_file,
                    const base::FilePath& output_file) {
   // SOX documentation for silence command: http://sox.sourceforge.net/sox.html
   // To remove the silence from both beginning and end of the audio file, we
   // call sox silence command twice: once on normal file and again on its
   // reverse, then we reverse the final output.
   // Silence parameters are (in sequence):
   // ABOVE_PERIODS: The period for which silence occurs. Value 1 is used for
   //                 silence at beginning of audio.
   // DURATION: the amount of time in seconds that non-silence must be detected
   //           before sox stops trimming audio.
   // THRESHOLD: value used to indicate what sample value is treats as silence.
   const char* kAbovePeriods = "1";
   const char* kDuration = "2";
   const char* kTreshold = "3%";
 
-  CommandLine command_line = MakeSoxCommandLine();
+  base::CommandLine command_line = MakeSoxCommandLine();
   if (command_line.GetProgram().empty())
     return false;
   command_line.AppendArgPath(input_file);
   command_line.AppendArgPath(output_file);
   command_line.AppendArg("silence");
   command_line.AppendArg(kAbovePeriods);
   command_line.AppendArg(kDuration);
   command_line.AppendArg(kTreshold);
   command_line.AppendArg("reverse");
   command_line.AppendArg("silence");
   command_line.AppendArg(kAbovePeriods);
   command_line.AppendArg(kDuration);
   command_line.AppendArg(kTreshold);
   command_line.AppendArg("reverse");
 
   DVLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   bool ok = base::GetAppOutput(command_line, &result);
   DVLOG(0) << "Output was:\n\n" << result;
   return ok;
 }
 
 // Looks for 0.3-second silences (under 1% audio power) and splits the input
 // file on those silences. Output files are written according to the output file
 // template (e.g. /tmp/out.wav writes /tmp/out001.wav, /tmp/out002.wav, etc if
 // there are two silence-padded regions in the file). The silences between
 // speech segments must be at least 500 ms for this to be reliable.
 bool SplitFileOnSilence(const base::FilePath& input_file,
                         const base::FilePath& output_file_template) {
-  CommandLine command_line = MakeSoxCommandLine();
+  base::CommandLine command_line = MakeSoxCommandLine();
   if (command_line.GetProgram().empty())
     return false;
 
   // These are experimentally determined and work on the files we use.
   const char* kAbovePeriods = "1";
   const char* kUnderPeriods = "1";
   const char* kDuration = "0.3";
   const char* kTreshold = "1%";
   command_line.AppendArgPath(input_file);
   command_line.AppendArgPath(output_file_template);
@@ skipping 48 matching lines @@
   base::FilePath pesq_path =
       test::GetReferenceFilesDir().Append(FILE_PATH_LITERAL("tools/pesq"));
 #endif
 
   if (!base::PathExists(pesq_path)) {
     LOG(ERROR) << "Missing PESQ binary in " << pesq_path.value()
                << "; you may have to provide this binary yourself.";
     return false;
   }
 
-  CommandLine command_line(pesq_path);
+  base::CommandLine command_line(pesq_path);
   command_line.AppendArg(base::StringPrintf("+%d", sample_rate));
   command_line.AppendArgPath(reference_file);
   command_line.AppendArgPath(actual_file);
 
   DVLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to run PESQ.";
     return false;
   }
@@ skipping 288 matching lines @@
 
 // Since the AGC is off here there should be no gain at all.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff) {
   const char* kAudioCallWithoutAudioProcessing =
       "{audio: { mandatory: { echoCancellation: false } } }";
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kAgcTestReferenceFile, kAudioCallWithoutAudioProcessing, "_no_agc"));
 }