Revert "Reland: URLRequestJob: change ReadRawData contract"

content/browser/service_worker/service_worker_read_from_cache_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_read_from_cache_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 23 matching lines @@
       context_(context),
       version_(version),
       resource_id_(resource_id),
       has_been_killed_(false),
       weak_factory_(this) {}
 
 ServiceWorkerReadFromCacheJob::~ServiceWorkerReadFromCacheJob() {
 }
 
 void ServiceWorkerReadFromCacheJob::Start() {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&ServiceWorkerReadFromCacheJob::StartAsync,
-                            weak_factory_.GetWeakPtr()));
+  TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
+                           "ServiceWorkerReadFromCacheJob::ReadInfo", this,
+                           "URL", request_->url().spec());
+  if (!context_) {
+    NotifyStartError(
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
+    return;
+  }
+
+  // Create a response reader and start reading the headers,
+  // we'll continue when thats done.
+  if (is_main_script())
+    version_->embedded_worker()->OnScriptReadStarted();
+  reader_ = context_->storage()->CreateResponseReader(resource_id_);
+  http_info_io_buffer_ = new HttpResponseInfoIOBuffer;
+  reader_->ReadInfo(
+      http_info_io_buffer_.get(),
+      base::Bind(&ServiceWorkerReadFromCacheJob::OnReadInfoComplete,
+                 weak_factory_.GetWeakPtr()));
+  SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
 }
 
 void ServiceWorkerReadFromCacheJob::Kill() {
   if (has_been_killed_)
     return;
   weak_factory_.InvalidateWeakPtrs();
   has_been_killed_ = true;
   reader_.reset();
   context_.reset();
   http_info_io_buffer_ = NULL;
@@ skipping 41 matching lines @@
       !net::HttpUtil::ParseRangeHeader(value, &ranges)) {
     return;
   }
 
   // If multiple ranges are requested, we play dumb and
   // return the entire response with 200 OK.
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
-int ServiceWorkerReadFromCacheJob::ReadRawData(net::IOBuffer* buf,
-                                               int buf_size) {
+bool ServiceWorkerReadFromCacheJob::ReadRawData(net::IOBuffer* buf,
+                                                int buf_size,
+                                                int* bytes_read) {
   DCHECK_NE(buf_size, 0);
+  DCHECK(bytes_read);
   DCHECK(!reader_->IsReadPending());
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerReadFromCacheJob::ReadRawData",
                            this,
                            "URL", request_->url().spec());
   reader_->ReadData(buf, buf_size,
                     base::Bind(&ServiceWorkerReadFromCacheJob::OnReadComplete,
                                weak_factory_.GetWeakPtr()));
-  return net::ERR_IO_PENDING;
-}
-
-void ServiceWorkerReadFromCacheJob::StartAsync() {
-  TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
-                           "ServiceWorkerReadFromCacheJob::ReadInfo", this,
-                           "URL", request_->url().spec());
-  if (!context_) {
-    // NotifyStartError is not safe to call synchronously in Start.
-    NotifyStartError(
-        net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
-    return;
-  }
-
-  // Create a response reader and start reading the headers,
-  // we'll continue when thats done.
-  if (is_main_script())
-    version_->embedded_worker()->OnScriptReadStarted();
-  reader_ = context_->storage()->CreateResponseReader(resource_id_);
-  http_info_io_buffer_ = new HttpResponseInfoIOBuffer;
-  reader_->ReadInfo(
-      http_info_io_buffer_.get(),
-      base::Bind(&ServiceWorkerReadFromCacheJob::OnReadInfoComplete,
-                 weak_factory_.GetWeakPtr()));
   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
+  return false;
 }
 
 const net::HttpResponseInfo* ServiceWorkerReadFromCacheJob::http_info() const {
   if (!http_info_)
     return NULL;
   if (range_response_info_)
     return range_response_info_.get();
   return http_info_.get();
 }
 
 void ServiceWorkerReadFromCacheJob::OnReadInfoComplete(int result) {
   scoped_refptr<ServiceWorkerReadFromCacheJob> protect(this);
   if (!http_info_io_buffer_->http_info) {
     DCHECK_LT(result, 0);
     ServiceWorkerMetrics::CountReadResponseResult(
         ServiceWorkerMetrics::READ_HEADERS_ERROR);
     Done(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
-    NotifyStartError(
-        net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
     return;
   }
   DCHECK_GE(result, 0);
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
   http_info_.reset(http_info_io_buffer_->http_info.release());
   if (is_range_request())
     SetupRangeResponse(http_info_io_buffer_->response_data_size);
   http_info_io_buffer_ = NULL;
   if (request_->url() == version_->script_url())
     version_->SetMainScriptHttpResponseInfo(*http_info_);
@@ skipping 33 matching lines @@
     version_->SetStartWorkerStatusCode(SERVICE_WORKER_ERROR_DISK_CACHE);
     // TODO(falken): Retry before evicting.
     if (context_) {
       ServiceWorkerRegistration* registration =
           context_->GetLiveRegistration(version_->registration_id());
       registration->DeleteVersion(version_);
     }
   }
   if (is_main_script())
     version_->embedded_worker()->OnScriptReadFinished();
+  NotifyDone(status);
 }
 
 void ServiceWorkerReadFromCacheJob::OnReadComplete(int result) {
   ServiceWorkerMetrics::ReadResponseResult check_result;
-
-  if (result >= 0) {
+  if (result == 0) {
     check_result = ServiceWorkerMetrics::READ_OK;
-    if (result == 0)
-      Done(net::URLRequestStatus());
-  } else {
+    Done(net::URLRequestStatus());
+  } else if (result < 0) {
     check_result = ServiceWorkerMetrics::READ_DATA_ERROR;
     Done(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
+  } else {
+    check_result = ServiceWorkerMetrics::READ_OK;
+    SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
   }
-
   ServiceWorkerMetrics::CountReadResponseResult(check_result);
-  ReadRawDataComplete(result);
+  NotifyReadComplete(result);
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerReadFromCacheJob::ReadRawData",
                          this,
                          "Result", result);
 }
 
 }  // namespace content