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
-      NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, ERR_INVALID_URL));
+      NotifyStartError(
+          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();
 }
 
-bool URLRequestTestJob::ReadRawData(IOBuffer* buf,
-                                    int buf_size,
-                                    int* bytes_read) {
+int URLRequestTestJob::ReadRawData(IOBuffer* buf, int buf_size) {
   if (stage_ == WAITING) {
     async_buf_ = buf;
     async_buf_size_ = buf_size;
-    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
-    return false;
+    return ERR_IO_PENDING;
   }
 
-  DCHECK(bytes_read);
-  *bytes_read = 0;
-
-  if (offset_ >= static_cast<int>(response_data_.length())) {
-    return true;  // done reading
-  }
+  if (offset_ >= static_cast<int>(response_data_.length()))
+    return 0;  // 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;
 
-  *bytes_read = to_read;
-  return true;
+  return to_read;
 }
 
 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 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
+        int result = ReadRawData(async_buf_, async_buf_size_);
+        if (result < 0)
+          NOTREACHED() << "Reads should not fail in DATA_AVAILABLE.";
         if (NextReadAsync()) {
           // Make all future reads return io pending until the next
           // ProcessNextOperation().
           stage_ = WAITING;
         }
-        NotifyReadComplete(bytes_read);
+        ReadRawDataComplete(result);
       }
       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