Fix stream errors that occur after a stream starts not propagating.

content/browser/streams/stream_url_request_job.cc

 // Copyright (c) 2013 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/streams/stream_url_request_job.h"
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 12 matching lines @@
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     scoped_refptr<Stream> stream)
     : net::URLRangeRequestJob(request, network_delegate),
       stream_(stream),
       headers_set_(false),
       pending_buffer_size_(0),
       total_bytes_read_(0),
       max_range_(0),
       request_failed_(false),
+      error_code_(0),

[tyoshino (SeeGerritForStatus), 2016/09/27 10:24:56]

how about net::OK so that it's clear that it's intended to hold a net error?

[jam, 2016/09/27 15:41:07]

Done.

       weak_factory_(this) {
   DCHECK(stream_.get());
   stream_->SetReadObserver(this);
 }
 
 StreamURLRequestJob::~StreamURLRequestJob() {
   ClearStream();
 }
 
 void StreamURLRequestJob::OnDataAvailable(Stream* stream) {
@@ skipping 42 matching lines @@
       base::Bind(&StreamURLRequestJob::DidStart, weak_factory_.GetWeakPtr()));
 }
 
 void StreamURLRequestJob::Kill() {
   net::URLRequestJob::Kill();
   weak_factory_.InvalidateWeakPtrs();
   ClearStream();
 }
 
 int StreamURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
-  // TODO(ellyjones): This is not right. The old code returned true here, but
-  // ReadRawData's old contract was to return true only for synchronous
-  // successes, which had the effect of treating all errors as synchronous EOFs.
-  // See https://crbug.com/508957
   if (request_failed_)
-    return 0;
+    return error_code_;
 
   DCHECK(buf);
   int to_read = buf_size;
   if (max_range_ && to_read) {
     if (to_read + total_bytes_read_ > max_range_)
       to_read = max_range_ - total_bytes_read_;
 
     if (to_read == 0)
       return 0;
   }
 
   int bytes_read = 0;
   switch (stream_->ReadRawData(buf, to_read, &bytes_read)) {
     case Stream::STREAM_HAS_DATA:
-    case Stream::STREAM_COMPLETE:
       total_bytes_read_ += bytes_read;
       return bytes_read;
+    case Stream::STREAM_COMPLETE:
+      return stream_->GetStatus();
     case Stream::STREAM_EMPTY:
       pending_buffer_ = buf;
       pending_buffer_size_ = to_read;
       return net::ERR_IO_PENDING;
     case Stream::STREAM_ABORTED:
       // Handle this as connection reset.
       return net::ERR_CONNECTION_RESET;
   }
   NOTREACHED();
   return net::ERR_FAILED;
@@ skipping 34 matching lines @@
   if (request()->method() != "GET") {
     NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
     return;
   }
 
   HeadersCompleted(net::HTTP_OK);
 }
 
 void StreamURLRequestJob::NotifyFailure(int error_code) {
   request_failed_ = true;
+  error_code_ = error_code;
 
   // This method can only be called before headers are set.
   DCHECK(!headers_set_);
 
   // TODO(zork): Share these with BlobURLRequestJob.
   net::HttpStatusCode status_code = net::HTTP_INTERNAL_SERVER_ERROR;
   switch (error_code) {
     case net::ERR_ACCESS_DENIED:
       status_code = net::HTTP_FORBIDDEN;
       break;
@@ skipping 36 matching lines @@
 }
 
 void StreamURLRequestJob::ClearStream() {
   if (stream_.get()) {
     stream_->RemoveReadObserver(this);
     stream_ = NULL;
   }
 }
 
 }  // namespace content