Rewrite guts of ResourceLoader and BufferedResourceHandler to suck less.

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"
@@ skipping 229 matching lines @@
   if (!read_buffer_) {
     *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,
+bool DownloadResourceHandler::OnReadCompleted(int request_id, int bytes_read,
                                               bool* defer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!read_buffer_) {
-    // Ignore spurious OnReadCompleted!  Deferring from OnReadCompleted tells
-    // the ResourceDispatcherHost that we did not consume the data.
-    // ResumeDeferredRequest then repeats the last OnReadCompleted call.
-    // TODO(darin): Fix the ResourceDispatcherHost to avoid this hack!
-    return true;
-  }
+  DCHECK(read_buffer_);
 
   if (pause_count_ > 0) {
     *defer = was_deferred_ = true;
     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 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)
+  if (!bytes_read)
     return true;
-  bytes_read_ += *bytes_read;
+  bytes_read_ += bytes_read;
   DCHECK(read_buffer_);
 
   // Take the data ship it down the stream.  If the stream is full, pause the
   // request; the stream callback will resume it.
-  if (!stream_writer_->Write(read_buffer_, *bytes_read)) {
+  if (!stream_writer_->Write(read_buffer_, bytes_read)) {
     PauseRequest();
     *defer = was_deferred_ = true;
     last_stream_pause_time_ = now;
   }
 
   read_buffer_ = NULL;  // Drop our reference.
 
   return true;
 }
 
@@ skipping 147 matching lines @@
   // false somewhere in the chain of resource handlers.
   CallStartedCB(DownloadId(), net::ERR_ACCESS_DENIED);
 
   // Remove output stream callback if a stream exists.
   if (stream_writer_.get())
     stream_writer_->RegisterCallback(base::Closure());
 
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }