Use ByteStream in downloads system to decouple source and sink.

content/browser/download/download_file_manager.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_manager.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/download/base_file.h"
-#include "content/browser/download/download_buffer.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/power_save_blocker.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 
 using content::BrowserThread;
 using content::DownloadFile;
 using content::DownloadId;
 using content::DownloadManager;
 
 namespace {
 
 class DownloadFileFactoryImpl
     : public DownloadFileManager::DownloadFileFactory {
  public:
   DownloadFileFactoryImpl() {}
 
   virtual content::DownloadFile* CreateFile(
       DownloadCreateInfo* info,
+      scoped_ptr<content::ByteStreamOutput> pipe,
       const DownloadRequestHandle& request_handle,
       DownloadManager* download_manager,
       bool calculate_hash,
       const net::BoundNetLog& bound_net_log) OVERRIDE;
 };
 
 DownloadFile* DownloadFileFactoryImpl::CreateFile(
     DownloadCreateInfo* info,
+    scoped_ptr<content::ByteStreamOutput> pipe,
     const DownloadRequestHandle& request_handle,
     DownloadManager* download_manager,
     bool calculate_hash,
     const net::BoundNetLog& bound_net_log) {
   return new DownloadFileImpl(
-      info, new DownloadRequestHandle(request_handle),
+      info, pipe.Pass(), new DownloadRequestHandle(request_handle),
       download_manager, calculate_hash,
       scoped_ptr<PowerSaveBlocker>(
           new PowerSaveBlocker(
               PowerSaveBlocker::kPowerSaveBlockPreventSystemSleep)).Pass(),
       bound_net_log);
 }
 
 }  // namespace
 
 DownloadFileManager::DownloadFileManager(DownloadFileFactory* factory)
@@ skipping 12 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFileManager::OnShutdown, this));
 }
 
 void DownloadFileManager::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   STLDeleteValues(&downloads_);
 }
 
 void DownloadFileManager::CreateDownloadFile(
-    DownloadCreateInfo* info, const DownloadRequestHandle& request_handle,
+    scoped_ptr<DownloadCreateInfo> info,
+    scoped_ptr<content::ByteStreamOutput> pipe,
+    const DownloadRequestHandle& request_handle,
     DownloadManager* download_manager, bool get_hash,
     const net::BoundNetLog& bound_net_log) {
-  DCHECK(info);
+  DCHECK(info.get());
   VLOG(20) << __FUNCTION__ << "()" << " info = " << info->DebugString();
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  // Life of |info| ends here. No more references to it after this method.
-  scoped_ptr<DownloadCreateInfo> infop(info);
-
   // Create the download file.
   scoped_ptr<DownloadFile> download_file(download_file_factory_->CreateFile(
-      info, request_handle, download_manager, get_hash, bound_net_log));
+      info.get(), pipe.Pass(), request_handle, download_manager,
+      get_hash, bound_net_log));
 
   net::Error init_result = download_file->Initialize();
   if (net::OK != init_result) {
     // Error:  Handle via download manager/item.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(
             &DownloadManager::OnDownloadInterrupted,
             download_manager,
             info->download_id.local(),
             0,
             "",
             content::ConvertNetErrorToInterruptReason(
                 init_result, content::DOWNLOAD_INTERRUPT_FROM_DISK)));
   } else {
     DCHECK(GetDownloadFile(info->download_id) == NULL);
     downloads_[info->download_id] = download_file.release();
-
-    // The file is now ready, we can un-pause the request and start saving data.
-    request_handle.ResumeRequest();
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadManager::StartDownload, download_manager,
                  info->download_id.local()));
 }
 
 DownloadFile* DownloadFileManager::GetDownloadFile(
     DownloadId global_id) {
@@ skipping 14 matching lines @@
                      manager,
                      global_id.local(),
                      download_file->BytesSoFar(),
                      download_file->CurrentSpeed(),
                      download_file->GetHashState()));
     }
   }
 }
 
 void DownloadFileManager::StartDownload(
-    DownloadCreateInfo* info, const DownloadRequestHandle& request_handle) {
+    scoped_ptr<DownloadCreateInfo> info,
+    scoped_ptr<content::ByteStreamOutput> pipe,
+    const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(info);
+  DCHECK(info.get());
 
   DownloadManager* manager = request_handle.GetDownloadManager();
   DCHECK(manager);  // Checked in |DownloadResourceHandler::StartOnUIThread()|.
 
   // |bound_net_log| will be used for logging the both the download item's and
   // the download file's events.
   net::BoundNetLog bound_net_log =
-      manager->CreateDownloadItem(info, request_handle);
+      manager->CreateDownloadItem(info.get(), request_handle);
   bool hash_needed = manager->GenerateFileHash();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFileManager::CreateDownloadFile, this,
-                 info, request_handle, make_scoped_refptr(manager),
+                 base::Passed(info.Pass()), base::Passed(pipe.Pass()),
+                 request_handle,
+                 make_scoped_refptr(manager),
                  hash_needed, bound_net_log));
 }
 
-// We don't forward an update to the UI thread here, since we want to throttle
-// the UI update rate via a periodic timer. If the user has cancelled the
-// download (in the UI thread), we may receive a few more updates before the IO
-// thread gets the cancel message: we just delete the data since the
-// DownloadFile has been deleted.
-void DownloadFileManager::UpdateDownload(
-    DownloadId global_id, content::DownloadBuffer* buffer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  scoped_ptr<content::ContentVector> contents(buffer->ReleaseContents());
-
-  download_stats::RecordFileThreadReceiveBuffers(contents->size());
-
-  DownloadFile* download_file = GetDownloadFile(global_id);
-  bool had_error = false;
-  for (size_t i = 0; i < contents->size(); ++i) {
-    net::IOBuffer* data = (*contents)[i].first;
-    const int data_len = (*contents)[i].second;
-    if (!had_error && download_file) {
-      net::Error write_result =
-          download_file->AppendDataToFile(data->data(), data_len);
-      if (write_result != net::OK) {
-        // Write failed: interrupt the download.
-        DownloadManager* download_manager =
-            download_file->GetDownloadManager();
-        had_error = true;
-
-        int64 bytes_downloaded = download_file->BytesSoFar();
-        std::string hash_state(download_file->GetHashState());
-
-        // Calling this here in case we get more data, to avoid
-        // processing data after an error.  That could lead to
-        // files that are corrupted if the later processing succeeded.
-        CancelDownload(global_id);
-        download_file = NULL;  // Was deleted in |CancelDownload|.
-
-        if (download_manager) {
-          BrowserThread::PostTask(
-              BrowserThread::UI, FROM_HERE,
-              base::Bind(&DownloadManager::OnDownloadInterrupted,
-                         download_manager,
-                         global_id.local(),
-                         bytes_downloaded,
-                         hash_state,
-                         content::ConvertNetErrorToInterruptReason(
-                             write_result,
-                             content::DOWNLOAD_INTERRUPT_FROM_DISK)));
-        }
-      }
-    }
-    data->Release();
-  }
-}
-
-void DownloadFileManager::OnResponseCompleted(
-    DownloadId global_id,
-    content::DownloadInterruptReason reason,
-    const std::string& security_info) {
-  VLOG(20) << __FUNCTION__ << "()" << " id = " << global_id
-           << " reason = " << InterruptReasonDebugString(reason)
-           << " security_info = \"" << security_info << "\"";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DownloadFile* download_file = GetDownloadFile(global_id);
-  if (!download_file)
-    return;
-
-  download_file->Finish();
-
-  DownloadManager* download_manager = download_file->GetDownloadManager();
-  if (!download_manager) {
-    CancelDownload(global_id);
-    return;
-  }
-
-  if (reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) {
-    std::string hash;
-    if (!download_file->GetHash(&hash) ||
-        BaseFile::IsEmptyHash(hash)) {
-      hash.clear();
-    }
-
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&DownloadManager::OnResponseCompleted,
-                   download_manager, global_id.local(),
-                   download_file->BytesSoFar(), hash));
-  } else {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&DownloadManager::OnDownloadInterrupted,
-                   download_manager,
-                   global_id.local(),
-                   download_file->BytesSoFar(),
-                   download_file->GetHashState(),
-                   reason));
-  }
-  // We need to keep the download around until the UI thread has finalized
-  // the name.
-}
-
 // This method will be sent via a user action, or shutdown on the UI thread, and
 // run on the download thread. Since this message has been sent from the UI
 // thread, the download may have already completed and won't exist in our map.
 void DownloadFileManager::CancelDownload(DownloadId global_id) {
   VLOG(20) << __FUNCTION__ << "()" << " id = " << global_id;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DownloadFileMap::iterator it = downloads_.find(global_id);
   if (it == downloads_.end())
     return;
 
@@ skipping 178 matching lines @@
   DownloadFile* download_file = downloads_[global_id];
 
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " id = " << global_id
            << " download_file = " << download_file->DebugString();
 
   downloads_.erase(global_id);
 
   delete download_file;
 }