Split DownloadFile::Rename into RenameAndUniquify and RenameAndAnnotate.

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 227 matching lines @@
       EXPECT_CALL(*(observer_.get()), DestinationCompleted(_));
       loop_.RunAllPending();
       ::testing::Mock::VerifyAndClearExpectations(observer_.get());
       EXPECT_CALL(*(observer_.get()), DestinationUpdate(_, _, _))
           .Times(AnyNumber())
           .WillRepeatedly(Invoke(this,
                                  &DownloadFileTest::SetUpdateDownloadInfo));
     }
   }
 
-  DownloadInterruptReason Rename(
-      const FilePath& full_path, bool overwrite_existing_file,
+  DownloadInterruptReason RenameAndUniquify(
+      const FilePath& full_path,
       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;
 
-    download_file_->Rename(full_path, overwrite_existing_file,
-                           base::Bind(&DownloadFileTest::SetRenameResult,
-                                      weak_ptr_factory.GetWeakPtr(),
-                                      &callback_was_called,
-                                      &result_reason, result_path_p));
+    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) {
+    base::WeakPtrFactory<DownloadFileTest> weak_ptr_factory(this);
+    DownloadInterruptReason result_reason(DOWNLOAD_INTERRUPT_REASON_NONE);
+    bool callback_was_called(false);
+    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_.RunAllPending();
 
     EXPECT_TRUE(callback_was_called);
     return result_reason;
   }
 
  protected:
   scoped_ptr<StrictMock<MockDownloadDestinationObserver> > observer_;
   base::WeakPtrFactory<DownloadDestinationObserver> observer_factory_;
 
@@ skipping 56 matching lines @@
   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;
 
   // Rename the file before downloading any data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            Rename(path_1, false, &output_path));
+            RenameAndUniquify(path_1, &output_path));
   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);
 
   // Rename the file after downloading some data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            Rename(path_2, false, &output_path));
+            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));
 
   const char* chunks2[] = { kTestData3 };
   AppendDataToFile(chunks2, 1);
 
   // Rename the file after downloading all the data.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            Rename(path_3, false, &output_path));
+            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));
 
   // 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_.RunAllPending();
 
   // Rename the file after downloading all the data and closing the file.
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            Rename(path_4, false, &output_path));
+            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));
 
   // 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));
   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));
   EXPECT_TRUE(file_util::ReadFileToString(path_5, &file_contents));
   EXPECT_EQ(std::string(file_data), file_contents);
 
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
-            Rename(path_5, true, &output_path));
+            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));
   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)"));
 
   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,
-            Rename(path_1, false, NULL));
+  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_.RunAllPending();
   DestroyDownloadFile(0);
 }
 
 // Test to make sure we get the proper error on failure.
 TEST_F(DownloadFileTest, RenameError) {
   ASSERT_TRUE(CreateDownloadFile(0, true));
@@ skipping 10 matching lines @@
   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,
-              Rename(target_path, true, NULL));
+              RenameAndAnnotate(target_path, NULL));
     EXPECT_FALSE(file_util::PathExists(target_path_suffixed));
   }
 
   FinishStream(DOWNLOAD_INTERRUPT_REASON_NONE, true);
   loop_.RunAllPending();
   DestroyDownloadFile(0);
 }
 
 // Various tests of the StreamActive method.
 TEST_F(DownloadFileTest, StreamEmptySuccess) {
@@ skipping 103 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