Revert "Reland: URLRequestJob: change ReadRawData contract"

ios/web/webui/url_data_manager_ios_backend.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 "ios/web/webui/url_data_manager_ios_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 78 matching lines @@
  public:
   // |is_incognito| set when job is generated from an incognito profile.
   URLRequestChromeJob(net::URLRequest* request,
                       net::NetworkDelegate* network_delegate,
                       BrowserState* browser_state,
                       bool is_incognito);
 
   // net::URLRequestJob implementation.
   void Start() override;
   void Kill() override;
-  int ReadRawData(net::IOBuffer* buf, int buf_size) override;
+  bool ReadRawData(net::IOBuffer* buf, int buf_size, int* bytes_read) override;
   bool GetMimeType(std::string* mime_type) const override;
   int GetResponseCode() const override;
   void GetResponseInfo(net::HttpResponseInfo* info) override;
 
   // Used to notify that the requested data's |mime_type| is ready.
   void MimeTypeAvailable(const std::string& mime_type);
 
   // Called by ChromeURLDataManagerIOS to notify us that the data blob is ready
   // for us.
   void DataAvailable(base::RefCountedMemory* bytes);
@@ skipping 25 matching lines @@
   // Returns true when job was generated from an incognito profile.
   bool is_incognito() const { return is_incognito_; }
 
  private:
   friend class URLDataManagerIOSBackend;
 
   ~URLRequestChromeJob() override;
 
   // Do the actual copy from data_ (the data we're serving) into |buf|.
   // Separate from ReadRawData so we can handle async I/O.
-  int CompleteRead(net::IOBuffer* buf, int buf_size);
+  void CompleteRead(net::IOBuffer* buf, int buf_size, int* bytes_read);
 
   // The actual data we're serving.  NULL until it's been fetched.
   scoped_refptr<base::RefCountedMemory> data_;
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   scoped_refptr<net::IOBuffer> pending_buf_;
@@ skipping 128 matching lines @@
 }
 
 void URLRequestChromeJob::MimeTypeAvailable(const std::string& mime_type) {
   set_mime_type(mime_type);
   NotifyHeadersComplete();
 }
 
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   if (bytes) {
+    // The request completed, and we have all the data.
+    // Clear any IO pending status.
+    SetStatus(net::URLRequestStatus());
+
     data_ = bytes;
+    int bytes_read;
     if (pending_buf_.get()) {
       CHECK(pending_buf_->data());
-      int rv = CompleteRead(pending_buf_.get(), pending_buf_size_);
+      CompleteRead(pending_buf_.get(), pending_buf_size_, &bytes_read);
       pending_buf_ = NULL;
-      ReadRawDataComplete(rv);
+      NotifyReadComplete(bytes_read);
     }
   } else {
-    ReadRawDataComplete(net::ERR_FAILED);
+    // The request failed.
+    NotifyDone(
+        net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
   }
 }
 
-int URLRequestChromeJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
+bool URLRequestChromeJob::ReadRawData(net::IOBuffer* buf,
+                                      int buf_size,
+                                      int* bytes_read) {
   if (!data_.get()) {
+    SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
     DCHECK(!pending_buf_.get());
     CHECK(buf->data());
     pending_buf_ = buf;
     pending_buf_size_ = buf_size;
-    return net::ERR_IO_PENDING;  // Tell the caller we're still waiting for
-                                 // data.
+    return false;  // Tell the caller we're still waiting for data.
   }
 
   // Otherwise, the data is available.
-  return CompleteRead(buf, buf_size);
+  CompleteRead(buf, buf_size, bytes_read);
+  return true;
 }
 
-int URLRequestChromeJob::CompleteRead(net::IOBuffer* buf, int buf_size) {
+void URLRequestChromeJob::CompleteRead(net::IOBuffer* buf,
+                                       int buf_size,
+                                       int* bytes_read) {
   // http://crbug.com/373841
   char url_buf[128];
   base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
-  int remaining = data_->size() - data_offset_;
+  int remaining = static_cast<int>(data_->size()) - data_offset_;
   if (buf_size > remaining)
     buf_size = remaining;
   if (buf_size > 0) {
     memcpy(buf->data(), data_->front() + data_offset_, buf_size);
     data_offset_ += buf_size;
   }
-  return buf_size;
+  *bytes_read = buf_size;
 }
 
 namespace {
 
 // Gets mime type for data that is available from |source| by |path|.
 // After that, notifies |job| that mime type is available. This method
 // should be called on the UI thread, but notification is performed on
 // the IO thread.
 void GetMimeTypeOnUI(URLDataSourceIOSImpl* source,
                      const std::string& path,
@@ skipping 185 matching lines @@
   // Forward this data on to the pending net::URLRequest, if it exists.
   PendingRequestMap::iterator i = pending_requests_.find(request_id);
   if (i != pending_requests_.end()) {
     URLRequestChromeJob* job(i->second);
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
 }  // namespace web