Move PathExists to base namespace.

chrome/browser/media/chrome_webrtc_video_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 "base/environment.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
@@ skipping 91 matching lines @@
   WebrtcVideoQualityBrowserTest()
       : peerconnection_server_(0),
         pywebsocket_server_(0),
         environment_(base::Environment::Create()) {}
 
   virtual void SetUp() OVERRIDE {
     RunPeerConnectionServer();
     InProcessBrowserTest::SetUp();
 
     // Ensure we have the stuff we need.
-    EXPECT_TRUE(file_util::PathExists(GetWorkingDir()))
+    EXPECT_TRUE(base::PathExists(GetWorkingDir()))
         << "Cannot find the working directory for the reference video and "
            "the temporary files:" << GetWorkingDir().value();
     base::FilePath reference_file =
         GetWorkingDir().Append(kReferenceYuvFileName);
-    EXPECT_TRUE(file_util::PathExists(reference_file))
+    EXPECT_TRUE(base::PathExists(reference_file))
         << "Cannot find the reference file to be used for video quality "
         << "comparison: " << reference_file.value();
   }
 
   virtual void TearDown() OVERRIDE {
     ShutdownPeerConnectionServer();
     InProcessBrowserTest::TearDown();
     ShutdownPyWebSocketServer();
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // TODO(phoglund): check that user actually has the requisite devices and
     // print a nice message if not; otherwise the test just times out which can
     // be confusing.
     // 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))
         << "You cannot run this test with fake devices.";
   }
 
   void StartPyWebSocketServer() {
     base::FilePath path_pywebsocket_dir =
         GetSourceDir().Append(FILE_PATH_LITERAL("third_party/pywebsocket/src"));
     base::FilePath pywebsocket_server = path_pywebsocket_dir.Append(
         FILE_PATH_LITERAL("mod_pywebsocket/standalone.py"));
     base::FilePath path_to_data_handler =
         GetSourceDir().Append(FILE_PATH_LITERAL("chrome/test/functional"));
 
-    EXPECT_TRUE(file_util::PathExists(pywebsocket_server))
+    EXPECT_TRUE(base::PathExists(pywebsocket_server))
         << "Fatal: missing pywebsocket server.";
-    EXPECT_TRUE(file_util::PathExists(path_to_data_handler))
+    EXPECT_TRUE(base::PathExists(path_to_data_handler))
         << "Fatal: missing data handler for pywebsocket server.";
 
     AppendToPythonPath(path_pywebsocket_dir);
     CommandLine pywebsocket_command = MakePythonCommand(pywebsocket_server);
 
     // Construct the command line manually, the server doesn't support -arg=val.
     pywebsocket_command.AppendArg("-p");
     pywebsocket_command.AppendArg(kPyWebSocketPortNumber);
     pywebsocket_command.AppendArg("-d");
     pywebsocket_command.AppendArgPath(path_to_data_handler);
@@ skipping 110 matching lines @@
   // which should contain frames of size |width| x |height|.
   //
   // The rgba_to_i420_converter is part of the webrtc_test_tools target which
   // should be build prior to running this test. The resulting binary should
   // live next to Chrome.
   void RunARGBtoI420Converter(int width,
                               int height,
                               const base::FilePath& captured_video_filename) {
     base::FilePath path_to_converter = base::MakeAbsoluteFilePath(
         GetBrowserDir().Append(kArgbToI420ConverterExecutable));
-    EXPECT_TRUE(file_util::PathExists(path_to_converter))
+    EXPECT_TRUE(base::PathExists(path_to_converter))
         << "Missing ARGB->I420 converter: should be in "
         << path_to_converter.value();
 
     CommandLine converter_command(path_to_converter);
     converter_command.AppendSwitchPath("--frames_dir", GetWorkingDir());
     converter_command.AppendSwitchPath("--output_file",
                                        captured_video_filename);
     converter_command.AppendSwitchASCII("--width",
                                         base::StringPrintf("%d", width));
     converter_command.AppendSwitchASCII("--height",
@@ skipping 17 matching lines @@
   std::string CompareVideos(int width,
                             int height,
                             const base::FilePath& captured_video_filename,
                             const base::FilePath& reference_video_filename,
                             const base::FilePath& stats_file) {
     base::FilePath path_to_analyzer = base::MakeAbsoluteFilePath(
         GetBrowserDir().Append(kFrameAnalyzerExecutable));
     base::FilePath path_to_compare_script = GetSourceDir().Append(
         FILE_PATH_LITERAL("third_party/webrtc/tools/compare_videos.py"));
 
-    EXPECT_TRUE(file_util::PathExists(path_to_analyzer))
+    EXPECT_TRUE(base::PathExists(path_to_analyzer))
         << "Missing frame analyzer: should be in " << path_to_analyzer.value();
-    EXPECT_TRUE(file_util::PathExists(path_to_compare_script))
+    EXPECT_TRUE(base::PathExists(path_to_compare_script))
         << "Missing video compare script: should be in "
         << path_to_compare_script.value();
 
     CommandLine compare_command = MakePythonCommand(path_to_compare_script);
     compare_command.AppendSwitchPath("--ref_video", reference_video_filename);
     compare_command.AppendSwitchPath("--test_video", captured_video_filename);
     compare_command.AppendSwitchPath("--frame_analyzer", path_to_analyzer);
     compare_command.AppendSwitchASCII("--yuv_frame_width",
                                       base::StringPrintf("%d", width));
     compare_command.AppendSwitchASCII("--yuv_frame_height",
@@ skipping 89 matching lines @@
                                                home_dir.end());
     return base::FilePath(native_home_dir).Append(kWorkingDirName);
   }
 
  private:
   void RunPeerConnectionServer() {
     // TODO(phoglund): de-dupe later: next line differs from original.
     base::FilePath peerconnection_server =
         GetBrowserDir().Append(kPeerConnectionServer);
 
-    EXPECT_TRUE(file_util::PathExists(peerconnection_server))
+    EXPECT_TRUE(base::PathExists(peerconnection_server))
         << "Missing peerconnection_server. You must build "
            "it so it ends up next to the browser test binary.";
     EXPECT_TRUE(base::LaunchProcess(CommandLine(peerconnection_server),
                                     base::LaunchOptions(),
                                     &peerconnection_server_))
         << "Failed to launch peerconnection_server.";
   }
 
   void ShutdownPeerConnectionServer() {
     EXPECT_TRUE(base::KillProcess(peerconnection_server_, 0, false))
@@ skipping 77 matching lines @@
   std::string output =
       CompareVideos(kVgaWidth,
                     kVgaHeight,
                     GetWorkingDir().Append(kCapturedYuvFileName),
                     GetWorkingDir().Append(kReferenceYuvFileName),
                     GetWorkingDir().Append(kStatsFileName));
 
   PrintFramesCountPerfResults(output);
   PrintPsnrAndSsimPerfResults(output);
 }