net: Rename URLRequestStatus::os_error_.

chrome/browser/sync/glue/http_bridge.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 "chrome/browser/sync/glue/http_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/browser_thread.h"
@@ skipping 99 matching lines @@
 HttpBridge::RequestContext::~RequestContext() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   delete http_transaction_factory();
 }
 
 HttpBridge::URLFetchState::URLFetchState() : url_poster(NULL),
                                              aborted(false),
                                              request_completed(false),
                                              request_succeeded(false),
                                              http_response_code(-1),
-                                             os_error_code(-1) {}
+                                             error_code(-1) {}
 HttpBridge::URLFetchState::~URLFetchState() {}
 
 HttpBridge::HttpBridge(HttpBridge::RequestContextGetter* context_getter)
     : context_getter_for_request_(context_getter),
       created_on_loop_(MessageLoop::current()),
       http_post_completed_(false, false) {
 }
 
 HttpBridge::~HttpBridge() {
 }
@@ skipping 43 matching lines @@
   if (!content || (content_length == 0)) {
     DCHECK_EQ(content_length, 0);
     request_content_ = " ";  // TODO(timsteele): URLFetcher requires non-empty
                              // content for POSTs whereas CURL does not, for now
                              // we hack this to support the sync backend.
   } else {
     request_content_.assign(content, content_length);
   }
 }
 
-bool HttpBridge::MakeSynchronousPost(int* os_error_code, int* response_code) {
+bool HttpBridge::MakeSynchronousPost(int* error_code, int* response_code) {
   DCHECK_EQ(MessageLoop::current(), created_on_loop_);
   if (DCHECK_IS_ON()) {
     base::AutoLock lock(fetch_state_lock_);
     DCHECK(!fetch_state_.request_completed);
   }
   DCHECK(url_for_request_.is_valid()) << "Invalid URL for request";
   DCHECK(!content_type_.empty()) << "Payload not set";
 
   if (!BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(this, &HttpBridge::CallMakeAsynchronousPost))) {
     // This usually happens when we're in a unit test.
     LOG(WARNING) << "Could not post CallMakeAsynchronousPost task";
     return false;
   }
 
   if (!http_post_completed_.Wait())  // Block until network request completes
     NOTREACHED();                    // or is aborted. See OnURLFetchComplete
                                      // and Abort.
 
   base::AutoLock lock(fetch_state_lock_);
   DCHECK(fetch_state_.request_completed || fetch_state_.aborted);
-  *os_error_code = fetch_state_.os_error_code;
+  *error_code = fetch_state_.error_code;
   *response_code = fetch_state_.http_response_code;
   return fetch_state_.request_succeeded;
 }
 
 void HttpBridge::MakeAsynchronousPost() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::AutoLock lock(fetch_state_lock_);
   DCHECK(!fetch_state_.request_completed);
   if (fetch_state_.aborted)
     return;
@@ skipping 36 matching lines @@
 void HttpBridge::Abort() {
   base::AutoLock lock(fetch_state_lock_);
   DCHECK(!fetch_state_.aborted);
   if (fetch_state_.aborted || fetch_state_.request_completed)
     return;
 
   fetch_state_.aborted = true;
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
                             fetch_state_.url_poster);
   fetch_state_.url_poster = NULL;
-  fetch_state_.os_error_code = net::ERR_ABORTED;
+  fetch_state_.error_code = net::ERR_ABORTED;
   http_post_completed_.Signal();
 }
 
 void HttpBridge::OnURLFetchComplete(const URLFetcher *source,
                                     const GURL &url,
                                     const net::URLRequestStatus &status,
                                     int response_code,
                                     const net::ResponseCookies &cookies,
                                     const std::string &data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   base::AutoLock lock(fetch_state_lock_);
   if (fetch_state_.aborted)
     return;
 
   fetch_state_.request_completed = true;
   fetch_state_.request_succeeded =
       (net::URLRequestStatus::SUCCESS == status.status());
   fetch_state_.http_response_code = response_code;
-  fetch_state_.os_error_code = status.os_error();
+  fetch_state_.error_code = status.error();
 
   fetch_state_.response_content = data;
   fetch_state_.response_headers = source->response_headers();
 
   // End of the line for url_poster_. It lives only on the IO loop.
   // We defer deletion because we're inside a callback from a component of the
   // URLFetcher, so it seems most natural / "polite" to let the stack unwind.
   MessageLoop::current()->DeleteSoon(FROM_HERE, fetch_state_.url_poster);
   fetch_state_.url_poster = NULL;
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 }  // namespace browser_sync