Revert "Reland: URLRequestJob: change ReadRawData contract"

content/browser/service_worker/service_worker_url_request_job.cc

 // Copyright 2014 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/service_worker/service_worker_url_request_job.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 185 matching lines @@
   if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header) ||
       !net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
     return;
   }
 
   // We don't support multiple range requests in one single URL request.
   if (ranges.size() == 1U)
     byte_range_ = ranges[0];
 }
 
-int ServiceWorkerURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
+bool ServiceWorkerURLRequestJob::ReadRawData(net::IOBuffer* buf,
+                                             int buf_size,
+                                             int* bytes_read) {
   DCHECK(buf);
   DCHECK_GE(buf_size, 0);
+  DCHECK(bytes_read);
   DCHECK(waiting_stream_url_.is_empty());
-
-  int bytes_read = 0;
-
   if (stream_.get()) {
-    switch (stream_->ReadRawData(buf, buf_size, &bytes_read)) {
+    switch (stream_->ReadRawData(buf, buf_size, bytes_read)) {
       case Stream::STREAM_HAS_DATA:
-        DCHECK_GT(bytes_read, 0);
-        return bytes_read;
+        DCHECK_GT(*bytes_read, 0);
+        return true;
       case Stream::STREAM_COMPLETE:
-        DCHECK_EQ(0, bytes_read);
+        DCHECK(!*bytes_read);
         RecordResult(ServiceWorkerMetrics::REQUEST_JOB_STREAM_RESPONSE);
-        return 0;
+        return true;
       case Stream::STREAM_EMPTY:
         stream_pending_buffer_ = buf;
         stream_pending_buffer_size_ = buf_size;
-        return net::ERR_IO_PENDING;
+        SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
+        return false;
       case Stream::STREAM_ABORTED:
         // Handle this as connection reset.
         RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_STREAM_ABORTED);
-        return net::ERR_CONNECTION_RESET;
+        NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                         net::ERR_CONNECTION_RESET));
+        return false;
     }
     NOTREACHED();
-    return net::ERR_FAILED;
+    return false;
   }
 
-  if (!blob_request_)
-    return 0;
-  blob_request_->Read(buf, buf_size, &bytes_read);
+  if (!blob_request_) {
+    *bytes_read = 0;
+    return true;
+  }
+  blob_request_->Read(buf, buf_size, bytes_read);
   net::URLRequestStatus status = blob_request_->status();
-  if (status.status() != net::URLRequestStatus::SUCCESS)
-    return status.error();
-  if (bytes_read == 0)
+  SetStatus(status);
+  if (status.is_io_pending())
+    return false;
+  if (status.is_success() && *bytes_read == 0)
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_BLOB_RESPONSE);
-  return bytes_read;
+  return status.is_success();
 }
 
 // TODO(falken): Refactor Blob and Stream specific handling to separate classes.
 // Overrides for Blob reading -------------------------------------------------
 
 void ServiceWorkerURLRequestJob::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   NOTREACHED();
@@ skipping 25 matching lines @@
 
 void ServiceWorkerURLRequestJob::OnResponseStarted(net::URLRequest* request) {
   // TODO(falken): Add Content-Length, Content-Type if they were not provided in
   // the ServiceWorkerResponse.
   response_time_ = base::Time::Now();
   CommitResponseHeader();
 }
 
 void ServiceWorkerURLRequestJob::OnReadCompleted(net::URLRequest* request,
                                                  int bytes_read) {
+  SetStatus(request->status());
   if (!request->status().is_success()) {
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_BLOB_READ);
-  } else if (bytes_read == 0) {
+    NotifyDone(request->status());
+    return;
+  }
+
+  if (bytes_read == 0) {
+    // Protect because NotifyReadComplete() can destroy |this|.
+    scoped_refptr<ServiceWorkerURLRequestJob> protect(this);
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_BLOB_RESPONSE);
+    NotifyReadComplete(bytes_read);
+    NotifyDone(request->status());
+    return;
   }
-  net::URLRequestStatus status = request->status();
-  ReadRawDataComplete(status.is_success() ? bytes_read : status.error());
+  NotifyReadComplete(bytes_read);
 }
 
 // Overrides for Stream reading -----------------------------------------------
 
 void ServiceWorkerURLRequestJob::OnDataAvailable(Stream* stream) {
+  // Clear the IO_PENDING status.
+  SetStatus(net::URLRequestStatus());
   // Do nothing if stream_pending_buffer_ is empty, i.e. there's no ReadRawData
   // operation waiting for IO completion.
   if (!stream_pending_buffer_.get())
     return;
 
   // stream_pending_buffer_ is set to the IOBuffer instance provided to
   // ReadRawData() by URLRequestJob.
 
-  int result = 0;
+  int bytes_read = 0;
   switch (stream_->ReadRawData(stream_pending_buffer_.get(),
-                               stream_pending_buffer_size_, &result)) {
+                               stream_pending_buffer_size_, &bytes_read)) {
     case Stream::STREAM_HAS_DATA:
-      DCHECK_GT(result, 0);
+      DCHECK_GT(bytes_read, 0);
       break;
     case Stream::STREAM_COMPLETE:
       // Calling NotifyReadComplete with 0 signals completion.
-      DCHECK(!result);
+      DCHECK(!bytes_read);
       RecordResult(ServiceWorkerMetrics::REQUEST_JOB_STREAM_RESPONSE);
       break;
     case Stream::STREAM_EMPTY:
       NOTREACHED();
       break;
     case Stream::STREAM_ABORTED:
       // Handle this as connection reset.
-      result = net::ERR_CONNECTION_RESET;
       RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_STREAM_ABORTED);
+      NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                       net::ERR_CONNECTION_RESET));
       break;
   }
 
   // Clear the buffers before notifying the read is complete, so that it is
   // safe for the observer to read.
   stream_pending_buffer_ = nullptr;
   stream_pending_buffer_size_ = 0;
-  ReadRawDataComplete(result);
+  NotifyReadComplete(bytes_read);
 }
 
 void ServiceWorkerURLRequestJob::OnStreamRegistered(Stream* stream) {
   StreamContext* stream_context =
       GetStreamContextForResourceContext(resource_context_);
   stream_context->registry()->RemoveRegisterObserver(waiting_stream_url_);
   waiting_stream_url_ = GURL();
   stream_ = stream;
   stream_->SetReadObserver(this);
   CommitResponseHeader();
@@ skipping 275 matching lines @@
     return;
   }
 
   // We should have a response now.
   DCHECK_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, fetch_result);
 
   // A response with status code 0 is Blink telling us to respond with network
   // error.
   if (response.status_code == 0) {
     RecordStatusZeroResponseError(response.error);
-    NotifyStartError(
+    NotifyDone(
         net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
     return;
   }
 
   load_timing_info_.send_end = base::TimeTicks::Now();
 
   // Creates a new HttpResponseInfo using the the ServiceWorker script's
   // HttpResponseInfo to show HTTPS padlock.
   // TODO(horo): When we support mixed-content (HTTP) no-cors requests from a
   // ServiceWorker, we have to check the security level of the responses.
@@ skipping 154 matching lines @@
   }
   if (!waiting_stream_url_.is_empty()) {
     StreamRegistry* stream_registry =
         GetStreamContextForResourceContext(resource_context_)->registry();
     stream_registry->RemoveRegisterObserver(waiting_stream_url_);
     stream_registry->AbortPendingStream(waiting_stream_url_);
   }
 }
 
 }  // namespace content