Move PathExists to base namespace.

content/browser/download/download_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 "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_file_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/byte_stream.h"
@@ skipping 322 matching lines @@
 
 const int32 DownloadFileTest::kDummyDownloadId = 23;
 const int DownloadFileTest::kDummyChildId = 3;
 const int DownloadFileTest::kDummyRequestId = 67;
 
 // Rename the file before any data is downloaded, after some has, after it all
 // has, and after it's closed.
 TEST_F(DownloadFileTest, RenameFileFinal) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath path_1(initial_path.InsertBeforeExtensionASCII("_1"));
   base::FilePath path_2(initial_path.InsertBeforeExtensionASCII("_2"));
   base::FilePath path_3(initial_path.InsertBeforeExtensionASCII("_3"));
   base::FilePath path_4(initial_path.InsertBeforeExtensionASCII("_4"));
   base::FilePath path_5(initial_path.InsertBeforeExtensionASCII("_5"));
   base::FilePath output_path;
 
   // Rename the file before downloading any data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             RenameAndUniquify(path_1, &output_path));
   base::FilePath renamed_path = download_file_->FullPath();
   EXPECT_EQ(path_1, renamed_path);
   EXPECT_EQ(path_1, output_path);
 
   // Check the files.
-  EXPECT_FALSE(file_util::PathExists(initial_path));
-  EXPECT_TRUE(file_util::PathExists(path_1));
+  EXPECT_FALSE(base::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(path_1));
 
   // Download the data.
   const char* chunks1[] = { kTestData1, kTestData2 };
   AppendDataToFile(chunks1, 2);
 
   // Rename the file after downloading some data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             RenameAndUniquify(path_2, &output_path));
   renamed_path = download_file_->FullPath();
   EXPECT_EQ(path_2, renamed_path);
   EXPECT_EQ(path_2, output_path);
 
   // Check the files.
-  EXPECT_FALSE(file_util::PathExists(path_1));
-  EXPECT_TRUE(file_util::PathExists(path_2));
+  EXPECT_FALSE(base::PathExists(path_1));
+  EXPECT_TRUE(base::PathExists(path_2));
 
   const char* chunks2[] = { kTestData3 };
   AppendDataToFile(chunks2, 1);
 
   // Rename the file after downloading all the data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             RenameAndUniquify(path_3, &output_path));
   renamed_path = download_file_->FullPath();
   EXPECT_EQ(path_3, renamed_path);
   EXPECT_EQ(path_3, output_path);
 
   // Check the files.
-  EXPECT_FALSE(file_util::PathExists(path_2));
-  EXPECT_TRUE(file_util::PathExists(path_3));
+  EXPECT_FALSE(base::PathExists(path_2));
+  EXPECT_TRUE(base::PathExists(path_3));
 
   // Should not be able to get the hash until the file is closed.
   std::string hash;
   EXPECT_FALSE(download_file_->GetHash(&hash));
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   loop_.RunUntilIdle();
 
   // Rename the file after downloading all the data and closing the file.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             RenameAndUniquify(path_4, &output_path));
   renamed_path = download_file_->FullPath();
   EXPECT_EQ(path_4, renamed_path);
   EXPECT_EQ(path_4, output_path);
 
   // Check the files.
-  EXPECT_FALSE(file_util::PathExists(path_3));
-  EXPECT_TRUE(file_util::PathExists(path_4));
+  EXPECT_FALSE(base::PathExists(path_3));
+  EXPECT_TRUE(base::PathExists(path_4));
 
   // Check the hash.
   EXPECT_TRUE(download_file_->GetHash(&hash));
   EXPECT_EQ(kDataHash, base::HexEncode(hash.data(), hash.size()));
 
   // Check that a rename with overwrite to an existing file succeeds.
   std::string file_contents;
-  ASSERT_FALSE(file_util::PathExists(path_5));
+  ASSERT_FALSE(base::PathExists(path_5));
   static const char file_data[] = "xyzzy";
   ASSERT_EQ(static_cast<int>(sizeof(file_data) - 1),
             file_util::WriteFile(path_5, file_data, sizeof(file_data) - 1));
-  ASSERT_TRUE(file_util::PathExists(path_5));
+  ASSERT_TRUE(base::PathExists(path_5));
   EXPECT_TRUE(file_util::ReadFileToString(path_5, &file_contents));
   EXPECT_EQ(std::string(file_data), file_contents);
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             RenameAndAnnotate(path_5, &output_path));
   EXPECT_EQ(path_5, output_path);
 
   file_contents = "";
   EXPECT_TRUE(file_util::ReadFileToString(path_5, &file_contents));
   EXPECT_NE(std::string(file_data), file_contents);
 
   DestroyDownloadFile(0);
 }
 
 // Test to make sure the rename uniquifies if we aren't overwriting
 // and there's a file where we're aiming.
 TEST_F(DownloadFileTest, RenameUniquifies) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
   base::FilePath path_1(initial_path.InsertBeforeExtensionASCII("_1"));
   base::FilePath path_1_suffixed(path_1.InsertBeforeExtensionASCII(" (1)"));
 
-  ASSERT_FALSE(file_util::PathExists(path_1));
+  ASSERT_FALSE(base::PathExists(path_1));
   static const char file_data[] = "xyzzy";
   ASSERT_EQ(static_cast<int>(sizeof(file_data)),
             file_util::WriteFile(path_1, file_data, sizeof(file_data)));
-  ASSERT_TRUE(file_util::PathExists(path_1));
+  ASSERT_TRUE(base::PathExists(path_1));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, RenameAndUniquify(path_1, NULL));
-  EXPECT_TRUE(file_util::PathExists(path_1_suffixed));
+  EXPECT_TRUE(base::PathExists(path_1_suffixed));
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   loop_.RunUntilIdle();
   DestroyDownloadFile(0);
 }
 
 // Test to make sure we get the proper error on failure.
 TEST_F(DownloadFileTest, RenameError) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
 
   // Create a subdirectory.
   base::FilePath tempdir(
       initial_path.DirName().Append(FILE_PATH_LITERAL("tempdir")));
   ASSERT_TRUE(file_util::CreateDirectory(tempdir));
   base::FilePath target_path(tempdir.Append(initial_path.BaseName()));
 
   // Targets
   base::FilePath target_path_suffixed(
       target_path.InsertBeforeExtensionASCII(" (1)"));
-  ASSERT_FALSE(file_util::PathExists(target_path));
-  ASSERT_FALSE(file_util::PathExists(target_path_suffixed));
+  ASSERT_FALSE(base::PathExists(target_path));
+  ASSERT_FALSE(base::PathExists(target_path_suffixed));
 
   // Make the directory unwritable and try to rename within it.
   {
     file_util::PermissionRestorer restorer(tempdir);
     ASSERT_TRUE(file_util::MakeFileUnwritable(tempdir));
 
     // Expect nulling out of further processing.
     EXPECT_CALL(*input_stream_, RegisterCallback(IsNullCallback()));
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED,
               RenameAndAnnotate(target_path, NULL));
-    EXPECT_FALSE(file_util::PathExists(target_path_suffixed));
+    EXPECT_FALSE(base::PathExists(target_path_suffixed));
   }
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   loop_.RunUntilIdle();
   DestroyDownloadFile(0);
 }
 
 // Various tests of the StreamActive method.
 TEST_F(DownloadFileTest, StreamEmptySuccess) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
 
   // Test that calling the sink_callback_ on an empty stream shouldn't
   // do anything.
   AppendDataToFile(NULL, 0);
 
   // Finish the download this way and make sure we see it on the
   // observer.
   EXPECT_CALL(*(observer_.get()), DestinationCompleted(_));
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, false);
   loop_.RunUntilIdle();
 
   DestroyDownloadFile(0);
 }
 
 TEST_F(DownloadFileTest, StreamEmptyError) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
 
   // Finish the download in error and make sure we see it on the
   // observer.
   EXPECT_CALL(*(observer_.get()),
               DestinationError(
                   DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED))
       .WillOnce(InvokeWithoutArgs(
           this, &DownloadFileTest::ConfirmUpdateDownloadInfo));
 
   // If this next EXPECT_CALL fails flakily, it's probably a real failure.
   // We'll be getting a stream of UpdateDownload calls from the timer, and
   // the last one may have the correct information even if the failure
   // doesn't produce an update, as the timer update may have triggered at the
   // same time.
   EXPECT_CALL(*(observer_.get()), CurrentUpdateStatus(0, _, _));
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED, false);
 
   loop_.RunUntilIdle();
 
   DestroyDownloadFile(0);
 }
 
 TEST_F(DownloadFileTest, StreamNonEmptySuccess) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
 
   const char* chunks1[] = { kTestData1, kTestData2 };
   ::testing::Sequence s1;
   SetupDataAppend(chunks1, 2, s1);
   SetupFinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, s1);
   EXPECT_CALL(*(observer_.get()), DestinationCompleted(_));
   sink_callback_.Run();
   VerifyStreamAndSize();
   loop_.RunUntilIdle();
   DestroyDownloadFile(0);
 }
 
 TEST_F(DownloadFileTest, StreamNonEmptyError) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
   base::FilePath initial_path(download_file_->FullPath());
-  EXPECT_TRUE(file_util::PathExists(initial_path));
+  EXPECT_TRUE(base::PathExists(initial_path));
 
   const char* chunks1[] = { kTestData1, kTestData2 };
   ::testing::Sequence s1;
   SetupDataAppend(chunks1, 2, s1);
   SetupFinishStream(DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED, s1);
 
   EXPECT_CALL(*(observer_.get()),
               DestinationError(
                   DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED))
       .WillOnce(InvokeWithoutArgs(
@@ skipping 30 matching lines @@
 
   EXPECT_EQ(static_cast<int64>(strlen(kTestData1) + strlen(kTestData2)),
             bytes_);
   EXPECT_EQ(download_file_->GetHashState(), hash_state_);
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   DestroyDownloadFile(0);
 }
 
 }  // namespace content