Adjust callers and networking delegates in net/ to modified APIs

net/test/spawned_test_server/spawner_communicator.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/test/spawned_test_server/spawner_communicator.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/json/json_reader.h"
@@ skipping 210 matching lines @@
   // is still applicable.
   if (!cur_request_.get())
     return;
   SpawnerRequestData* data =
       static_cast<SpawnerRequestData*>(cur_request_->GetUserData(this));
   DCHECK(data);
 
   if (!data->DoesRequestIdMatch(id))
     return;
   // Set the result code and cancel the timed-out task.
-  data->SetResultCode(ERR_TIMED_OUT);
-  cur_request_->Cancel();
-  OnSpawnerCommandCompleted(cur_request_.get());
+  int result = cur_request_->CancelWithError(ERR_TIMED_OUT);
+  OnSpawnerCommandCompleted(cur_request_.get(), result);
 }
 
-void SpawnerCommunicator::OnSpawnerCommandCompleted(URLRequest* request) {
+void SpawnerCommunicator::OnSpawnerCommandCompleted(URLRequest* request,
+                                                    int net_error) {
+  DCHECK_NE(ERR_IO_PENDING, net_error);
+
   if (!cur_request_.get())
     return;
   DCHECK_EQ(request, cur_request_.get());
   SpawnerRequestData* data =
       static_cast<SpawnerRequestData*>(cur_request_->GetUserData(this));
   DCHECK(data);
 
   // If request is faild,return the error code.
-  if (!cur_request_->status().is_success())
-    data->SetResultCode(cur_request_->status().error());
+  if (net_error != OK)
+    data->SetResultCode(net_error);
 
   if (!data->IsResultOK()) {
-    LOG(ERROR) << "request failed, status: "
-               << static_cast<int>(request->status().status())
-               << ", error: " << request->status().error();
+    LOG(ERROR) << "request failed, error: " << net_error;
     // Clear the buffer of received data if any net error happened.
     data->ClearReceivedData();
   } else {
     DCHECK_EQ(1, data->response_started_count());
   }
 
   // Clear current request to indicate the completion of sending a command
   // to spawner server and getting the result.
   cur_request_.reset();
   context_.reset();
   // Invalidate the weak pointers on the IO thread.
   weak_factory_.InvalidateWeakPtrs();
 
   // Wakeup the caller in user thread.
   event_.Signal();
 }
 
 void SpawnerCommunicator::ReadResult(URLRequest* request) {
   DCHECK_EQ(request, cur_request_.get());
   SpawnerRequestData* data =
       static_cast<SpawnerRequestData*>(cur_request_->GetUserData(this));
   DCHECK(data);
 
   IOBuffer* buf = data->buf();
   // Read as many bytes as are available synchronously.
   while (true) {
-    int num_bytes;
-    if (!request->Read(buf, kBufferSize, &num_bytes)) {
-      // Check whether the read failed synchronously.
-      if (!request->status().is_io_pending())
-        OnSpawnerCommandCompleted(request);
+    int rv = request->Read(buf, kBufferSize);
+    if (rv == ERR_IO_PENDING)
+      return;
+
+    if (rv < 0) {
+      OnSpawnerCommandCompleted(request, rv);
       return;
     }
-    if (!data->ConsumeBytesRead(num_bytes)) {
-      OnSpawnerCommandCompleted(request);
+
+    if (!data->ConsumeBytesRead(rv)) {
+      OnSpawnerCommandCompleted(request, rv);
       return;
     }
   }
 }
 
-void SpawnerCommunicator::OnResponseStarted(URLRequest* request) {
+void SpawnerCommunicator::OnResponseStarted(URLRequest* request,
+                                            int net_error) {
   DCHECK_EQ(request, cur_request_.get());
+  DCHECK_NE(ERR_IO_PENDING, net_error);
+
   SpawnerRequestData* data =
       static_cast<SpawnerRequestData*>(cur_request_->GetUserData(this));
   DCHECK(data);
 
   data->IncreaseResponseStartedCount();
 
-  if (!request->status().is_success()) {
-    OnSpawnerCommandCompleted(request);
+  if (net_error != OK) {
+    OnSpawnerCommandCompleted(request, net_error);
     return;
   }
 
   // Require HTTP responses to have a success status code.
   if (request->GetResponseCode() != 200) {
     LOG(ERROR) << "Spawner server returned bad status: "
                << request->response_headers()->GetStatusLine();
     data->SetResultCode(ERR_FAILED);
     request->Cancel();
-    OnSpawnerCommandCompleted(request);
+    OnSpawnerCommandCompleted(request, ERR_ABORTED);
     return;
   }
 
   ReadResult(request);
 }
 
 void SpawnerCommunicator::OnReadCompleted(URLRequest* request, int num_bytes) {
+  DCHECK_NE(ERR_IO_PENDING, num_bytes);
+
   if (!cur_request_.get())
     return;
   DCHECK_EQ(request, cur_request_.get());
   SpawnerRequestData* data =
       static_cast<SpawnerRequestData*>(cur_request_->GetUserData(this));
   DCHECK(data);
 
   if (data->ConsumeBytesRead(num_bytes)) {
     // Keep reading.
     ReadResult(request);
   } else {
-    OnSpawnerCommandCompleted(request);
+    // |bytes_read| < 0
+    int net_error = num_bytes;
+    OnSpawnerCommandCompleted(request, net_error);
   }
 }
 
 bool SpawnerCommunicator::StartServer(const std::string& arguments,
                                       uint16_t* port) {
   *port = 0;
   // Send the start command to spawner server to start the Python test server
   // on remote machine.
   std::string server_return_data;
   int result_code;
@@ skipping 39 matching lines @@
   std::string server_return_data;
   int result_code;
   SendCommandAndWaitForResult("kill", "", &result_code, &server_return_data);
   Shutdown();
   if (OK != result_code || server_return_data != "killed")
     return false;
   return true;
 }
 
 }  // namespace net