Move Rename functionality from DownloadFileManager to DownloadFileImple.

content/browser/download/download_file_impl.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/download_file_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 70 matching lines @@
   if (!update_timer_->IsRunning()) {
     update_timer_->Start(FROM_HERE,
                          base::TimeDelta::FromMilliseconds(kUpdatePeriodMs),
                          this, &DownloadFileImpl::SendUpdate);
   }
   return content::ConvertNetErrorToInterruptReason(
       file_.AppendDataToFile(data, data_len),
       content::DOWNLOAD_INTERRUPT_FROM_DISK);
 }
 
-content::DownloadInterruptReason DownloadFileImpl::Rename(
-    const FilePath& full_path) {
-  return content::ConvertNetErrorToInterruptReason(
-      file_.Rename(full_path),
-      content::DOWNLOAD_INTERRUPT_FROM_DISK);
+void DownloadFileImpl::Rename(const FilePath& full_path,
+                              bool overwrite_existing_file,
+                              const RenameCompletionCallback& callback) {
+  FilePath new_path(full_path);
+  if (!overwrite_existing_file) {
+    // Make the file unique if requested.
+    int uniquifier =
+        file_util::GetUniquePathNumber(new_path, FILE_PATH_LITERAL(""));
+    if (uniquifier > 0) {
+      new_path = new_path.InsertBeforeExtensionASCII(
+          StringPrintf(" (%d)", uniquifier));
+    }
+  }
+
+  net::Error rename_error = file_.Rename(new_path);
+  content::DownloadInterruptReason reason(
+      content::DOWNLOAD_INTERRUPT_REASON_NONE);
+  if (net::OK != rename_error) {
+    // Make sure our information is updated, since we're about to
+    // error out.
+    SendUpdate();
+
+    reason =
+        content::ConvertNetErrorToInterruptReason(
+            rename_error,
+            content::DOWNLOAD_INTERRUPT_FROM_DISK);
+
+    new_path.clear();
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, reason, new_path));
 }
 
 void DownloadFileImpl::Detach() {
   file_.Detach();
 }
 
 void DownloadFileImpl::Cancel() {
   file_.Cancel();
 }
 
@@ skipping 77 matching lines @@
 
     switch (state) {
       case content::ByteStreamReader::STREAM_EMPTY:
         break;
       case content::ByteStreamReader::STREAM_HAS_DATA:
         {
           ++num_buffers;
           base::TimeTicks write_start(base::TimeTicks::Now());
           reason = AppendDataToFile(
               incoming_data.get()->data(), incoming_data_size);
+          // Note that if we're after a rename failure but before any
+          // cancel that our owner generates based on that rename failure,
+          // we'll get an ERR_UNEXPECTED from the above.  Our consumers
+          // need to handle this situation.
           disk_writes_time_ += (base::TimeTicks::Now() - write_start);
           bytes_seen_ += incoming_data_size;
           total_incoming_data_size += incoming_data_size;
         }
         break;
       case content::ByteStreamReader::STREAM_COMPLETE:
         {
           reason = stream_reader_->GetStatus();
           SendUpdate();
           base::TimeTicks close_start(base::TimeTicks::Now());
@@ skipping 28 matching lines @@
 
   download_stats::RecordContiguousWriteTime(now - start);
 
   // Take care of communication with our controller.
   if (reason != content::DOWNLOAD_INTERRUPT_REASON_NONE) {
     // Error case for both upstream source and file write.
     // Shut down processing and signal an error to our controller.
     // Our controller will clean us up.
     stream_reader_->RegisterCallback(base::Closure());
     weak_factory_.InvalidateWeakPtrs();
+    SendUpdate();                       // Make info up to date before error.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadManager::OnDownloadInterrupted,
-                   download_manager_, id_.local(),
-                   BytesSoFar(), GetHashState(), reason));
+                   download_manager_, id_.local(), reason));
   } else if (state == content::ByteStreamReader::STREAM_COMPLETE) {
     // Signal successful completion and shut down processing.
     stream_reader_->RegisterCallback(base::Closure());
     weak_factory_.InvalidateWeakPtrs();
     std::string hash;
     if (!GetHash(&hash) || file_.IsEmptyHash(hash))
       hash.clear();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadManager::OnResponseCompleted,
                    download_manager_, id_.local(),
                    BytesSoFar(), hash));
   }
   if (bound_net_log_.IsLoggingAllEvents()) {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_STREAM_DRAINED,
         base::Bind(&download_net_logs::FileStreamDrainedCallback,
                    total_incoming_data_size, num_buffers));
   }
 }
 
 void DownloadFileImpl::SendUpdate() {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadManager::UpdateDownload,
                  download_manager_, id_.local(),
                  BytesSoFar(), CurrentSpeed(), GetHashState()));
 }