Move PathExists to base namespace.

content/browser/download/base_file_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 "content/browser/download/base_file.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 61 matching lines @@
       // Make sure the data has been properly written to disk.
       std::string disk_data;
       EXPECT_TRUE(file_util::ReadFileToString(full_path, &disk_data));
       EXPECT_EQ(expected_data_, disk_data);
     }
 
     // Make sure the mock BrowserThread outlives the BaseFile to satisfy
     // thread checks inside it.
     base_file_.reset();
 
-    EXPECT_EQ(expect_file_survives_, file_util::PathExists(full_path));
+    EXPECT_EQ(expect_file_survives_, base::PathExists(full_path));
   }
 
   void ResetHash() {
     secure_hash_.reset(crypto::SecureHash::Create(crypto::SecureHash::SHA256));
     memcpy(sha256_hash_, kEmptySha256Hash, kSha256HashLen);
   }
 
   void UpdateHash(const char* data, size_t length) {
     secure_hash_->Update(data, length);
   }
@@ skipping 139 matching lines @@
 // Test the most basic scenario: just create the object and do a sanity check
 // on all its accessors. This is actually a case that rarely happens
 // in production, where we would at least Initialize it.
 TEST_F(BaseFileTest, CreateDestroy) {
   EXPECT_EQ(base::FilePath().value(), base_file_->full_path().value());
 }
 
 // Cancel the download explicitly.
 TEST_F(BaseFileTest, Cancel) {
   ASSERT_TRUE(InitializeFile());
-  EXPECT_TRUE(file_util::PathExists(base_file_->full_path()));
+  EXPECT_TRUE(base::PathExists(base_file_->full_path()));
   base_file_->Cancel();
-  EXPECT_FALSE(file_util::PathExists(base_file_->full_path()));
+  EXPECT_FALSE(base::PathExists(base_file_->full_path()));
   EXPECT_NE(base::FilePath().value(), base_file_->full_path().value());
 }
 
 // Write data to the file and detach it, so it doesn't get deleted
 // automatically when base_file_ is destructed.
 TEST_F(BaseFileTest, WriteAndDetach) {
   ASSERT_TRUE(InitializeFile());
   ASSERT_TRUE(AppendDataToFile(kTestData1));
   base_file_->Finish();
   base_file_->Detach();
@@ skipping 22 matching lines @@
 
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Rename the file after writing to it, then detach.
 TEST_F(BaseFileTest, WriteThenRenameAndDetach) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
-  EXPECT_FALSE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(new_path));
 
   ASSERT_TRUE(AppendDataToFile(kTestData1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, base_file_->Rename(new_path));
-  EXPECT_FALSE(file_util::PathExists(initial_path));
-  EXPECT_TRUE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(new_path));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Write data to the file once.
 TEST_F(BaseFileTest, SingleWrite) {
   ASSERT_TRUE(InitializeFile());
   ASSERT_TRUE(AppendDataToFile(kTestData1));
@@ skipping 109 matching lines @@
   // This will fail until getting the hash state is supported in SecureHash.
   EXPECT_STREQ(expected_hash_hex.c_str(),
                base::HexEncode(hash.data(), hash.size()).c_str());
 }
 
 // Rename the file after all writes to it.
 TEST_F(BaseFileTest, WriteThenRename) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
-  EXPECT_FALSE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(new_path));
 
   ASSERT_TRUE(AppendDataToFile(kTestData1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             base_file_->Rename(new_path));
-  EXPECT_FALSE(file_util::PathExists(initial_path));
-  EXPECT_TRUE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(new_path));
 
   base_file_->Finish();
 }
 
 // Rename the file while the download is still in progress.
 TEST_F(BaseFileTest, RenameWhileInProgress) {
   ASSERT_TRUE(InitializeFile());
 
   base::FilePath initial_path(base_file_->full_path());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
-  EXPECT_FALSE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(new_path));
 
   ASSERT_TRUE(AppendDataToFile(kTestData1));
 
   EXPECT_TRUE(base_file_->in_progress());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, base_file_->Rename(new_path));
-  EXPECT_FALSE(file_util::PathExists(initial_path));
-  EXPECT_TRUE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(new_path));
 
   ASSERT_TRUE(AppendDataToFile(kTestData2));
 
   base_file_->Finish();
 }
 
 // Test that a failed rename reports the correct error.
 TEST_F(BaseFileTest, RenameWithError) {
   ASSERT_TRUE(InitializeFile());
 
   // TestDir is a subdirectory in |temp_dir_| that we will make read-only so
   // that the rename will fail.
   base::FilePath test_dir(temp_dir_.path().AppendASCII("TestDir"));
   ASSERT_TRUE(file_util::CreateDirectory(test_dir));
 
   base::FilePath new_path(test_dir.AppendASCII("TestFile"));
-  EXPECT_FALSE(file_util::PathExists(new_path));
+  EXPECT_FALSE(base::PathExists(new_path));
 
   {
     file_util::PermissionRestorer restore_permissions_for(test_dir);
     ASSERT_TRUE(file_util::MakeFileUnwritable(test_dir));
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
               base_file_->Rename(new_path));
   }
 
   base_file_->Finish();
 }
@@ skipping 144 matching lines @@
   base::FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                   &temp_file));
   ASSERT_FALSE(temp_file.empty());
   EXPECT_STREQ(temp_file.DirName().value().c_str(),
                base_file_->full_path().DirName().value().c_str());
   base_file_->Finish();
 }
 
 }  // namespace content