Revert "Reland: URLRequestJob: change ReadRawData contract"

net/url_request/url_request_test_job.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 "net/url_request/url_request_test_job.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 192 matching lines @@
       std::string redirect_headers = test_redirect_to_url_2_headers();
       response_headers_ =
           new HttpResponseHeaders(net::HttpUtil::AssembleRawHeaders(
               redirect_headers.c_str(), redirect_headers.size()));
     } else {
       AdvanceJob();
 
       // unexpected url, return error
       // FIXME(brettw) we may want to use WININET errors or have some more types
       // of errors
-      NotifyStartError(
-          URLRequestStatus(URLRequestStatus::FAILED, ERR_INVALID_URL));
+      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, ERR_INVALID_URL));
       // FIXME(brettw): this should emulate a network error, and not just fail
       // initiating a connection
       return;
     }
   }
 
   AdvanceJob();
 
   this->NotifyHeadersComplete();
 }
 
-int URLRequestTestJob::ReadRawData(IOBuffer* buf, int buf_size) {
+bool URLRequestTestJob::ReadRawData(IOBuffer* buf,
+                                    int buf_size,
+                                    int* bytes_read) {
   if (stage_ == WAITING) {
     async_buf_ = buf;
     async_buf_size_ = buf_size;
-    return ERR_IO_PENDING;
+    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+    return false;
   }
 
-  if (offset_ >= static_cast<int>(response_data_.length()))
-    return 0;  // done reading
+  DCHECK(bytes_read);
+  *bytes_read = 0;
+
+  if (offset_ >= static_cast<int>(response_data_.length())) {
+    return true;  // done reading
+  }
 
   int to_read = buf_size;
   if (to_read + offset_ > static_cast<int>(response_data_.length()))
     to_read = static_cast<int>(response_data_.length()) - offset_;
 
   memcpy(buf->data(), &response_data_.c_str()[offset_], to_read);
   offset_ += to_read;
 
-  return to_read;
+  *bytes_read = to_read;
+  return true;
 }
 
 void URLRequestTestJob::GetResponseInfo(HttpResponseInfo* info) {
   if (response_headers_.get())
     info->headers = response_headers_;
 }
 
 void URLRequestTestJob::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
   // Preserve the times the URLRequest is responsible for, but overwrite all
@@ skipping 37 matching lines @@
 
 void URLRequestTestJob::ProcessNextOperation() {
   switch (stage_) {
     case WAITING:
       // Must call AdvanceJob() prior to NotifyReadComplete() since that may
       // delete |this|.
       AdvanceJob();
       stage_ = DATA_AVAILABLE;
       // OK if ReadRawData wasn't called yet.
       if (async_buf_) {
-        int result = ReadRawData(async_buf_, async_buf_size_);
-        if (result < 0)
-          NOTREACHED() << "Reads should not fail in DATA_AVAILABLE.";
+        int bytes_read;
+        if (!ReadRawData(async_buf_, async_buf_size_, &bytes_read))
+          NOTREACHED() << "This should not return false in DATA_AVAILABLE.";
+        SetStatus(URLRequestStatus());  // clear the io pending flag
         if (NextReadAsync()) {
           // Make all future reads return io pending until the next
           // ProcessNextOperation().
           stage_ = WAITING;
         }
-        ReadRawDataComplete(result);
+        NotifyReadComplete(bytes_read);
       }
       break;
     case DATA_AVAILABLE:
       AdvanceJob();
       stage_ = ALL_DATA;  // done sending data
       break;
     case ALL_DATA:
       stage_ = DONE;
       return;
     case DONE:
@@ skipping 25 matching lines @@
 
   URLRequestTestJob* next_job(g_pending_jobs.Get().front());
   g_pending_jobs.Get().pop_front();
 
   DCHECK(!next_job->auto_advance());  // auto_advance jobs should be in this q
   next_job->ProcessNextOperation();
   return true;
 }
 
 }  // namespace net