Use ByteStream in downloads system to decouple source and sink.

content/browser/download/download_resource_handler.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_resource_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/stringprintf.h"
-#include "content/browser/download/download_buffer.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_request_handle.h"
+#include "content/browser/download/byte_stream.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::ResourceDispatcherHostImpl;
 using content::ResourceRequestInfoImpl;
 
 namespace {
 
+static const int kDownloadPipeSize = 100 * 1024;
+
 void CallStartedCBOnUIThread(
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     DownloadId id,
     net::Error error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (started_cb.is_null())
     return;
   started_cb.Run(id, error);
 }
 
 }  // namespace
 
 DownloadResourceHandler::DownloadResourceHandler(
     int render_process_host_id,
     int render_view_id,
     int request_id,
     const GURL& url,
     DownloadFileManager* download_file_manager,
     net::URLRequest* request,
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     const content::DownloadSaveInfo& save_info)
     : download_id_(DownloadId::Invalid()),
       global_id_(render_process_host_id, request_id),
       render_view_id_(render_view_id),
       content_length_(0),
       download_file_manager_(download_file_manager),
       request_(request),
       started_cb_(started_cb),
       save_info_(save_info),
-      buffer_(new content::DownloadBuffer),
-      is_paused_(false),
       last_buffer_size_(0),
       bytes_read_(0) {
   download_stats::RecordDownloadCount(download_stats::UNTHROTTLED_COUNT);
 }
 
 bool DownloadResourceHandler::OnUploadProgress(int request_id,
                                                uint64 position,
                                                uint64 size) {
   return true;
 }
@@ skipping 30 matching lines @@
   set_content_length(response->content_length);
 
   const ResourceRequestInfoImpl* request_info =
       ResourceRequestInfoImpl::ForRequest(request_);
 
   // Deleted in DownloadManager.
   scoped_ptr<DownloadCreateInfo> info(new DownloadCreateInfo(
       base::Time::Now(), 0, content_length_, DownloadItem::IN_PROGRESS,
       request_->net_log(), request_info->has_user_gesture(),
       request_info->transition_type()));
+
+  // Create the ByteStream pipe for sending data to the download sink.
+  scoped_ptr<content::ByteStreamOutput> pipe_output;
+  CreateByteStream(
+      base::MessageLoopProxy::current(),
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
+      kDownloadPipeSize, &pipe_input_, &pipe_output);
+  pipe_input_->RegisterCallback(
+      // We're refcounted, so this is a safe callback to pass around.
+      base::Bind(&DownloadResourceHandler::ResumeRequest, this));
+
   info->url_chain = request_->url_chain();
   info->referrer_url = GURL(request_->referrer());
   info->start_time = base::Time::Now();
   info->received_bytes = save_info_.offset;
   info->total_bytes = content_length_;
   info->state = DownloadItem::IN_PROGRESS;
   info->has_user_gesture = request_info->has_user_gesture();
   info->content_disposition = content_disposition_;
   info->mime_type = response->mime_type;
   info->remote_address = request_->GetSocketAddress().host();
@@ skipping 24 matching lines @@
                                           "Accept-Ranges",
                                           &accept_ranges_)) {
     accept_ranges_ = "";
   }
 
   info->prompt_user_for_save_location =
       save_info_.prompt_for_save_location && save_info_.file_path.empty();
   info->referrer_charset = request_->context()->referrer_charset();
   info->save_info = save_info_;
 
-
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadResourceHandler::StartOnUIThread, this,
-                 base::Passed(&info), request_handle));
-
-  // We can't start saving the data before we create the file on disk and have a
-  // download id. The request will be un-paused in
-  // DownloadFileManager::CreateDownloadFile.
-  ResourceDispatcherHostImpl::Get()->PauseRequest(global_id_.child_id,
-                                                  global_id_.request_id,
-                                                  true);
+                 base::Passed(info.Pass()),
+                 base::Passed(pipe_output.Pass()),
+                 request_handle));
 
   return true;
 }
 
 void DownloadResourceHandler::CallStartedCB(DownloadId id, net::Error error) {
   if (started_cb_.is_null())
     return;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CallStartedCBOnUIThread, started_cb_, id, error));
@@ skipping 15 matching lines @@
     *buf_size = min_size < 0 ? kReadBufSize : min_size;
     last_buffer_size_ = *buf_size;
     read_buffer_ = new net::IOBuffer(*buf_size);
   }
   *buf = read_buffer_.get();
   return true;
 }
 
 // Pass the buffer to the download file writer.
 bool DownloadResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
+  if (!read_buffer_) {

[benjhayden, 2012/05/21 14:36:45]

Could Darin review the ResourceHandler-related parts of this cl?

[Randy Smith (Not in Mondays), 2012/05/23 03:33:15]

Sure, I'll ask him.  Even if he does, though, I'd like you to make sure I'm not
doing anything stupid with the callback/download id semantics--I'm going to be
tweaking them a little bit.

+    // Ignore spurious OnReadCompleted!  PauseRequest(true) called from within
+    // OnReadCompleted tells the ResourceDispatcherHost that we did not consume
+    // the data.  PauseRequest(false) then repeats the last OnReadCompleted
+    // call.  We pause the request after we transmit the buffer onwards, so
+    // the ResourceDispatcherHost pause mechanism does not fit our use
+    // case very well.
+    // Note that this test makes redundant the DCHECK() below; it's being left
+    // in in hopes that the TODO will be executed soon.
+    // TODO(darin): Fix the ResourceDispatcherHost to avoid this hack!
+    return true;
+  }
+
   base::TimeTicks now(base::TimeTicks::Now());
   if (!last_read_time_.is_null()) {
     double seconds_since_last_read = (now - last_read_time_).InSecondsF();
     if (now == last_read_time_)
       // Use 1/10 ms as a "very small number" so that we avoid
       // divide-by-zero error and still record a very high potential bandwidth.
       seconds_since_last_read = 0.00001;
 
     double actual_bandwidth = (*bytes_read)/seconds_since_last_read;
     double potential_bandwidth = last_buffer_size_/seconds_since_last_read;
     download_stats::RecordBandwidth(actual_bandwidth, potential_bandwidth);
   }
   last_read_time_ = now;
 
   if (!*bytes_read)
     return true;
   bytes_read_ += *bytes_read;
   DCHECK(read_buffer_);
-  // Swap the data.
-  net::IOBuffer* io_buffer = NULL;
-  read_buffer_.swap(&io_buffer);
-  size_t vector_size = buffer_->AddData(io_buffer, *bytes_read);
-  bool need_update = (vector_size == 1);  // Buffer was empty.
 
-  // We are passing ownership of this buffer to the download file manager.
-  if (need_update) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
-        base::Bind(&DownloadFileManager::UpdateDownload,
-                   download_file_manager_, download_id_, buffer_));
+  // Take the data ship it down the pipe.  If the pipe is full, pause the
+  // request; the pipe callback will resume it.
+  if (!pipe_input_->Write(read_buffer_, *bytes_read)) {
+    ResourceDispatcherHostImpl::Get()->PauseRequest(global_id_.child_id,
+                                                    global_id_.request_id,
+                                                    true);
+    last_pause_time_ = now;
   }
 
-  // We schedule a pause outside of the read loop if there is too much file
-  // writing work to do.
-  if (vector_size > kLoadsToWrite)
-    StartPauseTimer();
+  read_buffer_ = NULL;  // Drop our reference.
 
   return true;
 }
 
 bool DownloadResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   VLOG(20) << __FUNCTION__ << "()" << DebugString()
            << " request_id = " << request_id
            << " status.status() = " << status.status()
            << " status.error() = " << status.error();
   int response = status.is_success() ? request_->GetResponseCode() : 0;
   if (download_id_.IsValid()) {
     OnResponseCompletedInternal(request_id, status, security_info, response);
   } else {
     // We got cancelled before the task which sets the id ran on the IO thread.
     // Wait for it.
     BrowserThread::PostTaskAndReply(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&base::DoNothing),
         base::Bind(&DownloadResourceHandler::OnResponseCompletedInternal, this,
                    request_id, status, security_info, response));
   }
   // Can't trust request_ being value after this point.
   request_ = NULL;
+
+  // Stats
+  download_stats::RecordNetworkBandwidth(
+      bytes_read_, base::TimeTicks::Now() - download_start_time_,
+      total_pause_time_);
+
   return true;
 }
 
 void DownloadResourceHandler::OnResponseCompletedInternal(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info,
     int response_code) {
   // NOTE: |request_| may be a dangling pointer at this point.
   VLOG(20) << __FUNCTION__ << "()"
@@ skipping 39 matching lines @@
           break;
       }
     }
   }
 
   download_stats::RecordAcceptsRanges(accept_ranges_, bytes_read_);
 
   // If the callback was already run on the UI thread, this will be a noop.
   CallStartedCB(download_id_, error_code);
 
-  // We transfer ownership to |DownloadFileManager| to delete |buffer_|,
-  // so that any functions queued up on the FILE thread are executed
-  // before deletion.
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DownloadFileManager::OnResponseCompleted,
-                 download_file_manager_, download_id_, reason, security_info));
-  buffer_ = NULL;  // The buffer is longer needed by |DownloadResourceHandler|.
+  // Send the info down the pipe.  Conditional is in case we get
+  // OnResponseCompleted without OnResponseStarted.
+  if (pipe_input_.get())
+    pipe_input_->Close(reason);
+
+  pipe_input_.reset();  // We no longer need the pipe.
   read_buffer_ = NULL;
 }
 
 void DownloadResourceHandler::OnRequestClosed() {
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }
 
 void DownloadResourceHandler::StartOnUIThread(
     scoped_ptr<DownloadCreateInfo> info,
+    scoped_ptr<content::ByteStreamOutput> pipe,
     const DownloadRequestHandle& handle) {
   DownloadManager* download_manager = handle.GetDownloadManager();
   if (!download_manager) {
     // NULL in unittests or if the page closed right after starting the
     // download.
     CallStartedCB(download_id_, net::ERR_ACCESS_DENIED);
     return;
   }
   DownloadId download_id = download_manager->delegate()->GetNextId();
   info->download_id = download_id;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&DownloadResourceHandler::set_download_id, this,
                  info->download_id));
   // It's safe to continue on with download initiation before we have
   // confirmation that that download_id_ has been set on the IO thread, as any
   // messages generated by the UI thread that affect the IO thread will be
   // behind the message posted above.
-  download_file_manager_->StartDownload(info.release(), handle);
+  download_file_manager_->StartDownload(info.Pass(), pipe.Pass(), handle);
   CallStartedCB(download_id, net::OK);
 }
 
 void DownloadResourceHandler::set_download_id(content::DownloadId id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   download_id_ = id;
 }
 
 // If the content-length header is not present (or contains something other
 // than numbers), the incoming content_length is -1 (unknown size).
 // Set the content length to 0 to indicate unknown size to DownloadManager.
 void DownloadResourceHandler::set_content_length(const int64& content_length) {
   content_length_ = 0;
   if (content_length > 0)
     content_length_ = content_length;
 }
 
 void DownloadResourceHandler::set_content_disposition(
     const std::string& content_disposition) {
   content_disposition_ = content_disposition;
 }
 
-void DownloadResourceHandler::CheckWriteProgress() {
-  if (!buffer_.get())
-    return;  // The download completed while we were waiting to run.
-
-  size_t contents_size = buffer_->size();
-
-  bool should_pause = contents_size > kLoadsToWrite;
-
-  // We'll come back later and see if it's okay to unpause the request.
-  if (should_pause)
-    StartPauseTimer();
-
-  if (is_paused_ != should_pause) {
-    ResourceDispatcherHostImpl::Get()->PauseRequest(global_id_.child_id,
-                                                    global_id_.request_id,
-                                                    should_pause);
-    is_paused_ = should_pause;
-  }
-}
-
 DownloadResourceHandler::~DownloadResourceHandler() {
   // This won't do anything if the callback was called before.
   // If it goes through, it will likely be because OnWillStart() returned
   // false somewhere in the chain of resource handlers.
   CallStartedCB(download_id_, net::ERR_ACCESS_DENIED);
+
+  // Remove output pipe callback if a pipe exists.
+  if (pipe_input_.get())
+    pipe_input_->RegisterCallback(base::Closure());
 }
 
-void DownloadResourceHandler::StartPauseTimer() {
-  if (!pause_timer_.IsRunning())
-    pause_timer_.Start(FROM_HERE,
-                       base::TimeDelta::FromMilliseconds(kThrottleTimeMs), this,
-                       &DownloadResourceHandler::CheckWriteProgress);
+void DownloadResourceHandler::ResumeRequest() {
+  ResourceDispatcherHostImpl::Get()->PauseRequest(global_id_.child_id,
+                                                  global_id_.request_id,
+                                                  false);
+  total_pause_time_ += (base::TimeTicks::Now() - last_pause_time_);
 }
 
 std::string DownloadResourceHandler::DebugString() const {
   return base::StringPrintf("{"
                             " url_ = " "\"%s\""
                             " download_id_ = " "%d"
                             " global_id_ = {"
                             " child_id = " "%d"
                             " request_id = " "%d"
                             " }"
                             " render_view_id_ = " "%d"
                             " save_info_.file_path = \"%" PRFilePath "\""
                             " }",
                             request_ ?
                                 request_->url().spec().c_str() :
                                 "<NULL request>",
                             download_id_.local(),
                             global_id_.child_id,
                             global_id_.request_id,
                             render_view_id_,
                             save_info_.file_path.value().c_str());
 }