net: Rename URLRequestStatus::os_error_.

net/url_request/url_request.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.h"
 
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 465 matching lines @@
 void URLRequest::RestartWithJob(URLRequestJob *job) {
   DCHECK(job->request() == this);
   PrepareToRestart();
   StartJob(job);
 }
 
 void URLRequest::Cancel() {
   DoCancel(ERR_ABORTED, SSLInfo());
 }
 
-void URLRequest::SimulateError(int os_error) {
-  DoCancel(os_error, SSLInfo());
+void URLRequest::SimulateError(int error) {
+  DoCancel(error, SSLInfo());
 }
 
-void URLRequest::SimulateSSLError(int os_error, const SSLInfo& ssl_info) {
+void URLRequest::SimulateSSLError(int error, const SSLInfo& ssl_info) {
   // This should only be called on a started request.
   if (!is_pending_ || !job_ || job_->has_response_started()) {
     NOTREACHED();
     return;
   }
-  DoCancel(os_error, ssl_info);
+  DoCancel(error, ssl_info);
 }
 
-void URLRequest::DoCancel(int os_error, const SSLInfo& ssl_info) {
-  DCHECK(os_error < 0);
+void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
+  DCHECK(error < 0);
 
   // If the URL request already has an error status, then canceling is a no-op.
   // Plus, we don't want to change the error status once it has been set.
   if (status_.is_success()) {
     status_.set_status(URLRequestStatus::CANCELED);
-    status_.set_os_error(os_error);
+    status_.set_error(error);
     response_info_.ssl_info = ssl_info;
   }
 
   // There's nothing to do if we are not waiting on a Job.
   if (!is_pending_ || !job_)
     return;
 
   job_->Kill();
 
   // We need to notify about the end of this job here synchronously. The
@@ skipping 44 matching lines @@
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     delegate_->OnReceivedRedirect(this, location, defer_redirect);
   }
 }
 
 void URLRequest::NotifyResponseStarted() {
   scoped_refptr<NetLog::EventParameters> params;
   if (!status_.is_success())
-    params = new NetLogIntegerParameter("net_error", status_.os_error());
+    params = new NetLogIntegerParameter("net_error", status_.error());
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB, params);
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(this);
   if (job) {
     RestartWithJob(job);
   } else {
     if (delegate_) {
       // In some cases (e.g. an event was canceled), we might have sent the
       // completion event and receive a NotifyResponseStarted() later.
@@ skipping 136 matching lines @@
   scoped_refptr<const URLRequestContext> prev_context = context_;
 
   context_ = context;
 
   // If the context this request belongs to has changed, update the tracker.
   if (prev_context != context) {
     int net_error = OK;
     // Log error only on failure, not cancellation, as even successful requests
     // are "cancelled" on destruction.
     if (status_.status() == URLRequestStatus::FAILED)
-      net_error = status_.os_error();
+      net_error = status_.error();
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
     net_log_ = BoundNetLog();
 
     if (context) {
       net_log_ = BoundNetLog::Make(context->net_log(),
                                    NetLog::SOURCE_URL_REQUEST);
       net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE, NULL);
     }
   }
 }
@@ skipping 88 matching lines @@
   net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
 }
 
 void URLRequest::SetUnblockedOnDelegate() {
   blocked_on_delegate_ = false;
   load_state_param_.clear();
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
 }
 
 }  // namespace net