Adjust callers and networking delegates in net/ to modified APIs

net/url_request/url_request_data_job_fuzzer.cc

 // Copyright 2016 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 <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/run_loop.h"
@@ skipping 81 matching lines @@
     read_loop_ = nullptr;
     return 0;
   }
 
   void QuitLoop() {
     DCHECK(read_loop_);
     task_runner_->PostTask(FROM_HERE, read_loop_->QuitClosure());
   }
 
   void ReadFromRequest(net::URLRequest* request) {
-    bool sync = false;
+    int bytes_read = 0;
     do {
       // If possible, pop the next read size. If none exists, then this should
       // be the last call to Read.
       bool using_populated_read = read_lengths_.size() > 0;
       size_t read_size = 1;
       if (using_populated_read) {
         read_size = read_lengths_.back();
         read_lengths_.pop_back();
       }
 
-      int bytes_read = 0;
-      sync = request->Read(buf_.get(), read_size, &bytes_read);
-    } while (sync);
+      bytes_read = request->Read(buf_.get(), read_size);
+    } while (bytes_read > 0);
 
-    if (!request->status().is_io_pending())
+    if (bytes_read != net::ERR_IO_PENDING)
       QuitLoop();
   }
 
   // net::URLRequest::Delegate:
   void OnReceivedRedirect(net::URLRequest* request,
                           const net::RedirectInfo& redirect_info,
                           bool* defer_redirect) override {}
   void OnAuthRequired(net::URLRequest* request,
                       net::AuthChallengeInfo* auth_info) override {}
   void OnCertificateRequested(
       net::URLRequest* request,
       net::SSLCertRequestInfo* cert_request_info) override {}
   void OnSSLCertificateError(net::URLRequest* request,
                              const net::SSLInfo& ssl_info,
                              bool fatal) override {}
-  void OnResponseStarted(net::URLRequest* request) override {
-    DCHECK(!request->status().is_io_pending());
+  void OnResponseStarted(net::URLRequest* request, int net_error) override {
     DCHECK(buf_.get());
     DCHECK(read_loop_);
-    if (request->status().is_success()) {
+    DCHECK_NE(net::ERR_IO_PENDING, net_error);
+
+    if (net_error == net::OK) {
       ReadFromRequest(request);
     } else {
       QuitLoop();
     }
   }
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
-    DCHECK(!request->status().is_io_pending());
+    DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
     DCHECK(buf_.get());
     DCHECK(read_loop_);
-    if (request->status().is_success() && bytes_read > 0) {
+
+    if (bytes_read > 0) {
       ReadFromRequest(request);
     } else {
       QuitLoop();
     }
   }
 
  private:
   friend struct base::DefaultSingletonTraits<URLRequestDataJobFuzzerHarness>;
 
   net::TestURLRequestContext context_;
   net::URLRequestJobFactoryImpl job_factory_;
   std::vector<size_t> read_lengths_;
   scoped_refptr<net::IOBuffer> buf_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::RunLoop* read_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestDataJobFuzzerHarness);
 };
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   // Using a static singleton test harness lets the test run ~3-4x faster.
   return URLRequestDataJobFuzzerHarness::GetInstance()
       ->CreateAndReadFromDataURLRequest(data, size);
 }