Revert 146162 - 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);
 }
 
-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));
+content::DownloadInterruptReason DownloadFileImpl::Rename(
+    const FilePath& full_path) {
+  return content::ConvertNetErrorToInterruptReason(
+      file_.Rename(full_path),
+      content::DOWNLOAD_INTERRUPT_FROM_DISK);
 }
 
 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(), reason));
+                   download_manager_, id_.local(),
+                   BytesSoFar(), GetHashState(), 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()));
 }