Adjust callers and networking delegates in ios/ to modified APIs

ios/net/crn_http_protocol_handler.mm

 // Copyright 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.
 
 #import "ios/net/crn_http_protocol_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 132 matching lines @@
   void OnReceivedRedirect(URLRequest* request,
                           const RedirectInfo& new_url,
                           bool* defer_redirect) override;
   void OnAuthRequired(URLRequest* request,
                       AuthChallengeInfo* auth_info) override;
   void OnCertificateRequested(URLRequest* request,
                               SSLCertRequestInfo* cert_request_info) override;
   void OnSSLCertificateError(URLRequest* request,
                              const SSLInfo& ssl_info,
                              bool fatal) override;
-  void OnResponseStarted(URLRequest* request) override;
+  void OnResponseStarted(URLRequest* request, int net_error) override;
   void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
  private:
   friend class base::RefCountedThreadSafe<HttpProtocolHandlerCore,
                                           HttpProtocolHandlerCore>;
   friend class base::DeleteHelper<HttpProtocolHandlerCore>;
   ~HttpProtocolHandlerCore() override;
 
   // RefCountedThreadSafe traits implementation:
   static void Destruct(const HttpProtocolHandlerCore* x);
@@ skipping 282 matching lines @@
   } else {
     // The tracker will decide, eventually asking the user, and will invoke the
     // callback.
     RequestTracker::SSLCallback callback =
         base::Bind(&HttpProtocolHandlerCore::SSLErrorCallback, this);
     DCHECK(tracker_);
     tracker_->OnSSLCertificateError(request, ssl_info, !fatal, callback);
   }
 }
 
-void HttpProtocolHandlerCore::OnResponseStarted(URLRequest* request) {
+void HttpProtocolHandlerCore::OnResponseStarted(URLRequest* request,
+                                                int net_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
   if (net_request_ == nullptr)
     return;
 
-  const URLRequestStatus& status = request->status();
-  if (!status.is_success()) {
-    int error = status.error();
-    StopRequestWithError(IOSErrorCode(error), error);
+  if (net_error != net::OK) {
+    StopRequestWithError(IOSErrorCode(net_error), net_error);
     return;
   }
 
   if (tracker_ && IsCertStatusError(request->ssl_info().cert_status) &&
       !request->context()->GetNetworkSessionParams()->
           ignore_certificate_errors) {
     // The certificate policy cache is captured here because SSL errors do not
     // always trigger OnSSLCertificateError (this is the case when a page comes
     // from the HTTP cache).
     RequestTracker::SSLCallback callback =
@@ skipping 24 matching lines @@
 
     // Add clients from tracker.
     PushClients(
         tracker_->ClientsHandlingRequestAndResponse(*net_request_, response));
   }
 
   // Don't call any function on the response from now on, as the client may be
   // using it and the object is not re-entrant.
   [top_level_client_ didReceiveResponse:response];
 
-  int bytes_read = 0;
+  int bytes_read = net_request_->Read(buffer_.get(), kIOBufferSize);
+  if (bytes_read == net::ERR_IO_PENDING)
+    return;
 
-  if (net_request_->Read(buffer_.get(), kIOBufferSize, &bytes_read)) {
+  if (bytes_read >= 0) {
     OnReadCompleted(net_request_, bytes_read);
-  } else if (!net_request_->status().is_success()) {
-    int error = net_request_->status().error();
+  } else {
+    int error = bytes_read;
     StopRequestWithError(IOSErrorCode(error), error);
   }
 }
 
 void HttpProtocolHandlerCore::OnReadCompleted(URLRequest* request,
                                               int bytes_read) {
+  DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (net_request_ == nullptr)
     return;
 
   base::scoped_nsobject<NSMutableData> data([[NSMutableData alloc] init]);
 
   // Read all we can from the socket and put it into data.
   // TODO(droger): It may be possible to avoid some of the copies (using
   // WrappedIOBuffer for example).
   NSUInteger data_length;
-  bool loop = (bytes_read > 0);
-  bool io_pending = false;
-  uint64_t total_byte_read = loop ? bytes_read : 0;
-  while (loop) {
+  uint64_t total_byte_read = 0;
+  while (bytes_read > 0) {
+    total_byte_read += bytes_read;
     data_length = [data length];  // Assumes that getting the length is fast.
     [data increaseLengthBy:bytes_read];
     memcpy(reinterpret_cast<char*>([data mutableBytes]) + data_length,
            buffer_->data(), bytes_read);
-    io_pending = !request->Read(buffer_.get(), kIOBufferSize, &bytes_read);
-    loop = !io_pending && (bytes_read > 0);
-    total_byte_read += bytes_read;
+    request->Read(buffer_.get(), kIOBufferSize, &bytes_read);

[droger, 2016/09/05 09:21:31]

Do you want to update this call too?

[maksims (do not use this acc), 2016/09/05 10:39:12]

Yes. 
https://codereview.chromium.org/2262653003/diff/570001/net/url_request/url_re...

line 571. Old Read() is deprecated and I'll remove it as soon as all the callers
are modified.

   }
 
   if (tracker_)
     tracker_->CaptureReceivedBytes(request, total_byte_read);
 
   // Notify the client.
-  const URLRequestStatus& status = request->status();
-  if (status.is_success()) {
+  if (bytes_read == net::OK || bytes_read == net::ERR_IO_PENDING) {
     if ([data length] > 0) {
       // If the data is not encoded in UTF8, the NSString is nil.
       DVLOG(3) << "To client:" << std::endl
                << base::SysNSStringToUTF8([[[NSString alloc]
                       initWithData:data
                           encoding:NSUTF8StringEncoding] autorelease]);
       [top_level_client_ didLoadData:data];
     }
-    if (bytes_read == 0 && !io_pending) {
+    if (bytes_read == 0) {
       DCHECK_EQ(net_request_, request);
       // There is nothing more to read.
       StopNetRequest();
       [top_level_client_ didFinishLoading];
     }
   } else {
     // Request failed (not canceled).
-    int error = status.error();
+    int error = bytes_read;
     StopRequestWithError(IOSErrorCode(error), error);
   }
 }
 
 HttpProtocolHandlerCore::~HttpProtocolHandlerCore() {
   DCHECK(thread_checker_.CalledOnValidThread());
   [top_level_client_ cancelAuthRequest];
   DCHECK(!net_request_);
   DCHECK(!stream_delegate_);
 }
@@ skipping 517 matching lines @@
       [[DeferredCancellation alloc] initWithCore:[self getCore]];
   NSArray* modes = @[ [[NSRunLoop currentRunLoop] currentMode] ];
   [cancellation performSelector:@selector(cancel)
                        onThread:[self getClientThread]
                      withObject:nil
                   waitUntilDone:NO
                           modes:modes];
 }
 
 @end