net: Rename URLRequestStatus::os_error_.

net/url_request/url_request_test_util.cc

 // Copyright (c) 2011 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_util.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
@@ skipping 285 matching lines @@
   else if (cancel_in_rd_pending_)
     request->Cancel();
 }
 
 void TestDelegate::OnResponseCompleted(net::URLRequest* request) {
   if (quit_on_complete_)
     MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 TestNetworkDelegate::TestNetworkDelegate()
-  : last_os_error_(0),
+  : last_error_(0),
     error_count_(0),
     created_requests_(0),
     destroyed_requests_(0),
     completed_requests_(0) {
 }
 
 TestNetworkDelegate::~TestNetworkDelegate() {
   for (std::map<int, int>::iterator i = next_states_.begin();
        i != next_states_.end(); ++i) {
     event_order_[i->first] += "~TestNetworkDelegate\n";
@@ skipping 81 matching lines @@
 
 void TestNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
   int req_id = request->identifier();
   event_order_[req_id] += "OnResponseStarted\n";
   InitRequestStatesIfNew(req_id);
   EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted) <<
       event_order_[req_id];
   next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError;
   if (request->status().status() == net::URLRequestStatus::FAILED) {
     error_count_++;
-    last_os_error_ = request->status().os_error();
+    last_error_ = request->status().error();
   }
 }
 
 void TestNetworkDelegate::OnRawBytesRead(const net::URLRequest& request,
                                          int bytes_read) {
 }
 
 void TestNetworkDelegate::OnCompleted(net::URLRequest* request) {
   int req_id = request->identifier();
   event_order_[req_id] += "OnCompleted\n";
   InitRequestStatesIfNew(req_id);
   // Expect "Success -> (next_states_ & kStageCompletedSuccess)"
   // is logically identical to
   // Expect "!(Success) || (next_states_ & kStageCompletedSuccess)"
   EXPECT_TRUE(!request->status().is_success() ||
               (next_states_[req_id] & kStageCompletedSuccess)) <<
       event_order_[req_id];
   EXPECT_TRUE(request->status().is_success() ||
               (next_states_[req_id] & kStageCompletedError)) <<
       event_order_[req_id];
   next_states_[req_id] = kStageURLRequestDestroyed;
   completed_requests_++;
   if (request->status().status() == net::URLRequestStatus::FAILED) {
     error_count_++;
-    last_os_error_ = request->status().os_error();
+    last_error_ = request->status().error();
   }
 }
 
 void TestNetworkDelegate::OnURLRequestDestroyed(
     net::URLRequest* request) {
   int req_id = request->identifier();
   event_order_[req_id] += "OnURLRequestDestroyed\n";
   InitRequestStatesIfNew(req_id);
   EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) <<
       event_order_[req_id];
@@ skipping 10 matching lines @@
 }
 
 void TestNetworkDelegate::OnPACScriptError(int line_number,
                                            const string16& error) {
 }
 
 void TestNetworkDelegate::OnAuthRequired(
     net::URLRequest* reqest,
     const net::AuthChallengeInfo& auth_info) {
 }