Use base namespace for FilePath in content/browser

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 31 matching lines @@
   BaseFileTest()
       : expect_file_survives_(false),
         expect_in_progress_(true),
         expected_error_(DOWNLOAD_INTERRUPT_REASON_NONE),
         file_thread_(BrowserThread::FILE, &message_loop_) {
   }
 
   virtual void SetUp() {
     ResetHash();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    base_file_.reset(new BaseFile(FilePath(),
+    base_file_.reset(new BaseFile(base::FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   false,
                                   "",
                                   scoped_ptr<net::FileStream>(),
                                   net::BoundNetLog()));
   }
 
   virtual void TearDown() {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
       EXPECT_EQ(static_cast<int64>(expected_data_.size()),
                 base_file_->bytes_so_far());
     }
 
-    FilePath full_path = base_file_->full_path();
+    base::FilePath full_path = base_file_->full_path();
 
     if (!expected_data_.empty() && !expected_error_) {
       // 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.
@@ skipping 13 matching lines @@
 
   std::string GetFinalHash() {
     std::string hash;
     secure_hash_->Finish(sha256_hash_, kSha256HashLen);
     hash.assign(reinterpret_cast<const char*>(sha256_hash_),
                 sizeof(sha256_hash_));
     return hash;
   }
 
   void MakeFileWithHash() {
-    base_file_.reset(new BaseFile(FilePath(),
+    base_file_.reset(new BaseFile(base::FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   true,
                                   "",
                                   scoped_ptr<net::FileStream>(),
                                   net::BoundNetLog()));
   }
 
   bool InitializeFile() {
@@ skipping 17 matching lines @@
                   base_file_->bytes_so_far());
       }
     }
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
-  FilePath CreateTestFile() {
-    FilePath file_name;
-    BaseFile file(FilePath(),
+  base::FilePath CreateTestFile() {
+    base::FilePath file_name;
+    BaseFile file(base::FilePath(),
                   GURL(),
                   GURL(),
                   0,
                   false,
                   "",
                   scoped_ptr<net::FileStream>(),
                   net::BoundNetLog());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               file.Initialize(temp_dir_.path()));
     file_name = file.full_path();
-    EXPECT_NE(FilePath::StringType(), file_name.value());
+    EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               file.AppendDataToFile(kTestData4, kTestDataLength4));
 
     // Keep the file from getting deleted when existing_file_name is deleted.
     file.Detach();
 
     return file_name;
   }
 
   // Create a file with the specified file name.
-  void CreateFileWithName(const FilePath& file_name) {
-    EXPECT_NE(FilePath::StringType(), file_name.value());
+  void CreateFileWithName(const base::FilePath& file_name) {
+    EXPECT_NE(base::FilePath::StringType(), file_name.value());
     BaseFile duplicate_file(file_name,
                             GURL(),
                             GURL(),
                             0,
                             false,
                             "",
                             scoped_ptr<net::FileStream>(),
                             net::BoundNetLog());
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               duplicate_file.Initialize(temp_dir_.path()));
@@ skipping 47 matching lines @@
   BrowserThreadImpl file_thread_;
 };
 
 // This will initialize the entire array to zero.
 const unsigned char BaseFileTest::kEmptySha256Hash[] = { 0 };
 
 // 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(FilePath().value(), base_file_->full_path().value());
+  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()));
   base_file_->Cancel();
   EXPECT_FALSE(file_util::PathExists(base_file_->full_path()));
-  EXPECT_NE(FilePath().value(), base_file_->full_path().value());
+  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();
   expect_file_survives_ = true;
@@ skipping 20 matching lines @@
   EXPECT_EQ(expected_hash_hex, base::HexEncode(hash.data(), hash.size()));
 
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Rename the file after writing to it, then detach.
 TEST_F(BaseFileTest, WriteThenRenameAndDetach) {
   ASSERT_TRUE(InitializeFile());
 
-  FilePath initial_path(base_file_->full_path());
+  base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(file_util::PathExists(initial_path));
-  FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
+  base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
   EXPECT_FALSE(file_util::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));
 
   base_file_->Finish();
   base_file_->Detach();
@@ skipping 83 matching lines @@
   ASSERT_TRUE(InitializeFile());
   // Write some data
   ASSERT_TRUE(AppendDataToFile(kTestData1));
   ASSERT_TRUE(AppendDataToFile(kTestData2));
   // Get the hash state and file name.
   std::string hash_state;
   hash_state = base_file_->GetHashState();
   // Finish the file.
   base_file_->Finish();
 
-  FilePath new_file_path(temp_dir_.path().Append(
-      FilePath(FILE_PATH_LITERAL("second_file"))));
+  base::FilePath new_file_path(temp_dir_.path().Append(
+      base::FilePath(FILE_PATH_LITERAL("second_file"))));
 
   ASSERT_TRUE(file_util::CopyFile(base_file_->full_path(), new_file_path));
 
   // Create another file
   BaseFile second_file(new_file_path,
                        GURL(),
                        GURL(),
                        base_file_->bytes_so_far(),
                        true,
                        hash_state,
                        scoped_ptr<net::FileStream>(),
                        net::BoundNetLog());
   ASSERT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            second_file.Initialize(FilePath()));
+            second_file.Initialize(base::FilePath()));
   std::string data(kTestData3);
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
             second_file.AppendDataToFile(data.data(), data.size()));
   second_file.Finish();
 
   std::string hash;
   EXPECT_TRUE(second_file.GetHash(&hash));
   // 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());
 
-  FilePath initial_path(base_file_->full_path());
+  base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(file_util::PathExists(initial_path));
-  FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
+  base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
   EXPECT_FALSE(file_util::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));
 
   base_file_->Finish();
 }
 
 // Rename the file while the download is still in progress.
 TEST_F(BaseFileTest, RenameWhileInProgress) {
   ASSERT_TRUE(InitializeFile());
 
-  FilePath initial_path(base_file_->full_path());
+  base::FilePath initial_path(base_file_->full_path());
   EXPECT_TRUE(file_util::PathExists(initial_path));
-  FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
+  base::FilePath new_path(temp_dir_.path().AppendASCII("NewFile"));
   EXPECT_FALSE(file_util::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));
 
   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.
-  FilePath test_dir(temp_dir_.path().AppendASCII("TestDir"));
+  base::FilePath test_dir(temp_dir_.path().AppendASCII("TestDir"));
   ASSERT_TRUE(file_util::CreateDirectory(test_dir));
 
-  FilePath new_path(test_dir.AppendASCII("TestFile"));
+  base::FilePath new_path(test_dir.AppendASCII("TestFile"));
   EXPECT_FALSE(file_util::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();
 }
 
 // Write data to the file multiple times.
 TEST_F(BaseFileTest, MultipleWritesWithError) {
-  FilePath path;
+  base::FilePath path;
   ASSERT_TRUE(file_util::CreateTemporaryFile(&path));
   // Create a new file stream.  scoped_ptr takes ownership and passes it to
   // BaseFile; we use the pointer anyway and rely on the BaseFile not
   // deleting the MockFileStream until the BaseFile is reset.
   net::testing::MockFileStream* mock_file_stream(
       new net::testing::MockFileStream(NULL));
   scoped_ptr<net::FileStream> mock_file_stream_scoped_ptr(mock_file_stream);
 
   ASSERT_EQ(0,
             mock_file_stream->OpenSync(
@@ skipping 38 matching lines @@
   // Create another |BaseFile| referring to the file that |base_file_| owns.
   CreateFileWithName(base_file_->full_path());
 
   ASSERT_TRUE(AppendDataToFile(kTestData1));
   base_file_->Finish();
 }
 
 // Create a file and append to it.
 TEST_F(BaseFileTest, AppendToBaseFile) {
   // Create a new file.
-  FilePath existing_file_name = CreateTestFile();
+  base::FilePath existing_file_name = CreateTestFile();
 
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
   base_file_.reset(new BaseFile(existing_file_name,
                                 GURL(),
                                 GURL(),
                                 kTestDataLength4,
                                 false,
                                 "",
                                 scoped_ptr<net::FileStream>(),
                                 net::BoundNetLog()));
 
   ASSERT_TRUE(InitializeFile());
 
-  const FilePath file_name = base_file_->full_path();
-  EXPECT_NE(FilePath::StringType(), file_name.value());
+  const base::FilePath file_name = base_file_->full_path();
+  EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   EXPECT_TRUE(AppendDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 // Create a read-only file and attempt to write to it.
 TEST_F(BaseFileTest, ReadonlyBaseFile) {
   // Create a new file.
-  FilePath readonly_file_name = CreateTestFile();
+  base::FilePath readonly_file_name = CreateTestFile();
 
   // Restore permissions to the file when we are done with this test.
   file_util::PermissionRestorer restore_permissions(readonly_file_name);
 
   // Make it read-only.
   EXPECT_TRUE(file_util::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
   base_file_.reset(new BaseFile(readonly_file_name,
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
                                 "",
                                 scoped_ptr<net::FileStream>(),
                                 net::BoundNetLog()));
 
   expect_in_progress_ = false;
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
   EXPECT_FALSE(InitializeFile());
 
-  const FilePath file_name = base_file_->full_path();
-  EXPECT_NE(FilePath::StringType(), file_name.value());
+  const base::FilePath file_name = base_file_->full_path();
+  EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
   EXPECT_FALSE(AppendDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
@@ skipping 48 matching lines @@
 // Test that a temporary file is created in the default download directory.
 TEST_F(BaseFileTest, CreatedInDefaultDirectory) {
   ASSERT_TRUE(base_file_->full_path().empty());
   ASSERT_TRUE(InitializeFile());
   EXPECT_FALSE(base_file_->full_path().empty());
 
   // On Windows, CreateTemporaryFileInDir() will cause a path with short names
   // to be expanded into a path with long names. Thus temp_dir.path() might not
   // be a string-wise match to base_file_->full_path().DirName() even though
   // they are in the same directory.
-  FilePath temp_file;
+  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