Move PathExists to base namespace.

chrome/installer/setup/setup_util_unittest.cc

 // Copyright (c) 2012 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 "chrome/installer/setup/setup_util_unittest.h"
 
 #include <windows.h>
 
 #include <string>
 
@@ skipping 11 matching lines @@
 #include "chrome/installer/setup/setup_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class SetupUtilTestWithDir : public testing::Test {
  protected:
   virtual void SetUp() {
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_dir_));
     data_dir_ = data_dir_.AppendASCII("installer");
-    ASSERT_TRUE(file_util::PathExists(data_dir_));
+    ASSERT_TRUE(base::PathExists(data_dir_));
 
     // Create a temp directory for testing.
     ASSERT_TRUE(test_dir_.CreateUniqueTempDir());
   }
 
   virtual void TearDown() {
     // Clean up test directory manually so we can fail if it leaks.
     ASSERT_TRUE(test_dir_.Delete());
   }
 
@@ skipping 48 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 // Test that we are parsing Chrome version correctly.
 TEST_F(SetupUtilTestWithDir, ApplyDiffPatchTest) {
   base::FilePath work_dir(test_dir_.path());
   work_dir = work_dir.AppendASCII("ApplyDiffPatchTest");
-  ASSERT_FALSE(file_util::PathExists(work_dir));
+  ASSERT_FALSE(base::PathExists(work_dir));
   EXPECT_TRUE(file_util::CreateDirectory(work_dir));
-  ASSERT_TRUE(file_util::PathExists(work_dir));
+  ASSERT_TRUE(base::PathExists(work_dir));
 
   base::FilePath src = data_dir_.AppendASCII("archive1.7z");
   base::FilePath patch = data_dir_.AppendASCII("archive.diff");
   base::FilePath dest = work_dir.AppendASCII("archive2.7z");
   EXPECT_EQ(installer::ApplyDiffPatch(src, patch, dest, NULL), 0);
   base::FilePath base = data_dir_.AppendASCII("archive2.7z");
   EXPECT_TRUE(file_util::ContentsEqual(dest, base));
 
   EXPECT_EQ(installer::ApplyDiffPatch(base::FilePath(), base::FilePath(),
                                       base::FilePath(), NULL),
             6);
 }
 
 // Test that we are parsing Chrome version correctly.
 TEST_F(SetupUtilTestWithDir, GetMaxVersionFromArchiveDirTest) {
   // Create a version dir
   base::FilePath chrome_dir = test_dir_.path().AppendASCII("1.0.0.0");
   file_util::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(file_util::PathExists(chrome_dir));
+  ASSERT_TRUE(base::PathExists(chrome_dir));
   scoped_ptr<Version> version(
       installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
   ASSERT_EQ(version->GetString(), "1.0.0.0");
 
   base::Delete(chrome_dir, true);
-  ASSERT_FALSE(file_util::PathExists(chrome_dir));
+  ASSERT_FALSE(base::PathExists(chrome_dir));
   ASSERT_TRUE(installer::GetMaxVersionFromArchiveDir(test_dir_.path()) == NULL);
 
   chrome_dir = test_dir_.path().AppendASCII("ABC");
   file_util::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(file_util::PathExists(chrome_dir));
+  ASSERT_TRUE(base::PathExists(chrome_dir));
   ASSERT_TRUE(installer::GetMaxVersionFromArchiveDir(test_dir_.path()) == NULL);
 
   chrome_dir = test_dir_.path().AppendASCII("2.3.4.5");
   file_util::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(file_util::PathExists(chrome_dir));
+  ASSERT_TRUE(base::PathExists(chrome_dir));
   version.reset(installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
   ASSERT_EQ(version->GetString(), "2.3.4.5");
 
   // Create multiple version dirs, ensure that we select the greatest.
   chrome_dir = test_dir_.path().AppendASCII("9.9.9.9");
   file_util::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(file_util::PathExists(chrome_dir));
+  ASSERT_TRUE(base::PathExists(chrome_dir));
   chrome_dir = test_dir_.path().AppendASCII("1.1.1.1");
   file_util::CreateDirectory(chrome_dir);
-  ASSERT_TRUE(file_util::PathExists(chrome_dir));
+  ASSERT_TRUE(base::PathExists(chrome_dir));
 
   version.reset(installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
   ASSERT_EQ(version->GetString(), "9.9.9.9");
 }
 
 TEST_F(SetupUtilTestWithDir, DeleteFileFromTempProcess) {
   base::FilePath test_file;
   file_util::CreateTemporaryFileInDir(test_dir_.path(), &test_file);
-  ASSERT_TRUE(file_util::PathExists(test_file));
+  ASSERT_TRUE(base::PathExists(test_file));
   file_util::WriteFile(test_file, "foo", 3);
   EXPECT_TRUE(installer::DeleteFileFromTempProcess(test_file, 0));
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
-  EXPECT_FALSE(file_util::PathExists(test_file));
+  EXPECT_FALSE(base::PathExists(test_file));
 }
 
 // Note: This test is only valid when run at high integrity (i.e. it will fail
 // at medium integrity).
 TEST(SetupUtilTest, ScopedTokenPrivilegeBasic) {
   ASSERT_FALSE(CurrentProcessHasPrivilege(kTestedPrivilege));
 
   {
     installer::ScopedTokenPrivilege test_scoped_privilege(kTestedPrivilege);
     ASSERT_TRUE(test_scoped_privilege.is_enabled());
@@ skipping 98 matching lines @@
 // sufficiently recent operating systems.
 TEST(SetupUtilTest, AdjustFromBelowNormalPriority) {
   scoped_ptr<ScopedPriorityClass> below_normal =
       ScopedPriorityClass::Create(BELOW_NORMAL_PRIORITY_CLASS);
   ASSERT_TRUE(below_normal);
   if (base::win::GetVersion() > base::win::VERSION_SERVER_2003)
     EXPECT_EQ(PCCR_CHANGED, RelaunchAndDoProcessPriorityAdjustment());
   else
     EXPECT_EQ(PCCR_UNCHANGED, RelaunchAndDoProcessPriorityAdjustment());
 }