Use base namespace for FilePath in content/browser

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/string_number_conversions.h"
 #include "base/test/test_file_util.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/download/byte_stream.h"
@@ skipping 115 matching lines @@
     // TODO: Need to actually create a function that'll set the variables
     // based on the inputs from the callback.
     EXPECT_CALL(*input_stream_, RegisterCallback(_))
         .WillOnce(Invoke(this, &DownloadFileTest::RegisterCallback))
         .RetiresOnSaturation();
 
     scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
     download_file_.reset(
         new DownloadFileImpl(
             save_info.Pass(),
-            FilePath(),
+            base::FilePath(),
             GURL(),                     // Source
             GURL(),                     // Referrer
             calculate_hash,
             scoped_ptr<ByteStreamReader>(input_stream_),
             net::BoundNetLog(),
             scoped_ptr<PowerSaveBlocker>(NULL).Pass(),
             observer_factory_.GetWeakPtr()));
 
     EXPECT_CALL(*input_stream_, Read(_, _))
         .WillOnce(Return(ByteStreamReader::STREAM_EMPTY))
@@ skipping 92 matching lines @@
       loop_.RunUntilIdle();
       ::testing::Mock::VerifyAndClearExpectations(observer_.get());
       EXPECT_CALL(*(observer_.get()), DestinationUpdate(_, _, _))
           .Times(AnyNumber())
           .WillRepeatedly(Invoke(this,
                                  &DownloadFileTest::SetUpdateDownloadInfo));
     }
   }
 
   DownloadInterruptReason RenameAndUniquify(
-      const FilePath& full_path,
-      FilePath* result_path_p) {
+      const base::FilePath& full_path,
+      base::FilePath* result_path_p) {
     base::WeakPtrFactory<DownloadFileTest> weak_ptr_factory(this);
     DownloadInterruptReason result_reason(DOWNLOAD_INTERRUPT_REASON_NONE);
     bool callback_was_called(false);
-    FilePath result_path;
+    base::FilePath result_path;
 
     download_file_->RenameAndUniquify(
         full_path, base::Bind(&DownloadFileTest::SetRenameResult,
                               weak_ptr_factory.GetWeakPtr(),
                               &callback_was_called,
                               &result_reason, result_path_p));
     loop_.RunUntilIdle();
 
     EXPECT_TRUE(callback_was_called);
     return result_reason;
   }
 
   DownloadInterruptReason RenameAndAnnotate(
-      const FilePath& full_path,
-      FilePath* result_path_p) {
+      const base::FilePath& full_path,
+      base::FilePath* result_path_p) {
     base::WeakPtrFactory<DownloadFileTest> weak_ptr_factory(this);
     DownloadInterruptReason result_reason(DOWNLOAD_INTERRUPT_REASON_NONE);
     bool callback_was_called(false);
-    FilePath result_path;
+    base::FilePath result_path;
 
     download_file_->RenameAndAnnotate(
         full_path, base::Bind(&DownloadFileTest::SetRenameResult,
                               weak_ptr_factory.GetWeakPtr(),
                               &callback_was_called,
                               &result_reason, result_path_p));
     loop_.RunUntilIdle();
 
     EXPECT_TRUE(callback_was_called);
     return result_reason;
@@ skipping 16 matching lines @@
   // Latest update sent to the observer.
   int64 bytes_;
   int64 bytes_per_sec_;
   std::string hash_state_;
 
   MessageLoop loop_;
 
  private:
   void SetRenameResult(bool* called_p,
                        DownloadInterruptReason* reason_p,
-                       FilePath* result_path_p,
+                       base::FilePath* result_path_p,
                        DownloadInterruptReason reason,
-                       const FilePath& result_path) {
+                       const base::FilePath& result_path) {
     if (called_p)
       *called_p = true;
     if (reason_p)
       *reason_p = reason;
     if (result_path_p)
       *result_path_p = result_path;
   }
 
   // UI thread.
   BrowserThreadImpl ui_thread_;
@@ skipping 12 matching lines @@
     "CBF68BF10F8003DB86B31343AFAC8C7175BD03FB5FC905650F8C80AF087443A8";
 
 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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::PathExists(initial_path));
-  FilePath path_1(initial_path.InsertBeforeExtensionASCII("_1"));
-  FilePath path_2(initial_path.InsertBeforeExtensionASCII("_2"));
-  FilePath path_3(initial_path.InsertBeforeExtensionASCII("_3"));
-  FilePath path_4(initial_path.InsertBeforeExtensionASCII("_4"));
-  FilePath path_5(initial_path.InsertBeforeExtensionASCII("_5"));
-  FilePath output_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));
-  FilePath renamed_path = download_file_->FullPath();
+  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));
 
   // Download the data.
   const char* chunks1[] = { kTestData1, kTestData2 };
   AppendDataToFile(chunks1, 2);
@@ skipping 62 matching lines @@
   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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::PathExists(initial_path));
-  FilePath path_1(initial_path.InsertBeforeExtensionASCII("_1"));
-  FilePath path_1_suffixed(path_1.InsertBeforeExtensionASCII(" (1)"));
+  base::FilePath path_1(initial_path.InsertBeforeExtensionASCII("_1"));
+  base::FilePath path_1_suffixed(path_1.InsertBeforeExtensionASCII(" (1)"));
 
   ASSERT_FALSE(file_util::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));
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, RenameAndUniquify(path_1, NULL));
   EXPECT_TRUE(file_util::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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
 
   // Create a subdirectory.
-  FilePath tempdir(initial_path.DirName().Append(FILE_PATH_LITERAL("tempdir")));
+  base::FilePath tempdir(
+      initial_path.DirName().Append(FILE_PATH_LITERAL("tempdir")));
   ASSERT_TRUE(file_util::CreateDirectory(tempdir));
-  FilePath target_path(tempdir.Append(initial_path.BaseName()));
+  base::FilePath target_path(tempdir.Append(initial_path.BaseName()));
 
   // Targets
-  FilePath target_path_suffixed(target_path.InsertBeforeExtensionASCII(" (1)"));
+  base::FilePath target_path_suffixed(
+      target_path.InsertBeforeExtensionASCII(" (1)"));
   ASSERT_FALSE(file_util::PathExists(target_path));
   ASSERT_FALSE(file_util::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));
   }
 
   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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::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));
-  FilePath initial_path(download_file_->FullPath());
+  base::FilePath initial_path(download_file_->FullPath());
   EXPECT_TRUE(file_util::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))
@@ 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