net: Rename URLRequestStatus::os_error_.

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <shlobj.h>
 #include <windows.h>
 #endif
@@ skipping 206 matching lines @@
       r.set_method(method.c_str());
 
       r.AppendBytesToUpload(uploadBytes, kMsgSize);
 
       r.Start();
       EXPECT_TRUE(r.is_pending());
 
       MessageLoop::current()->Run();
 
       ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
-          (int) r.status().status() << ", os error: " << r.status().os_error();
+          (int) r.status().status() << ", os error: " << r.status().error();
 
       EXPECT_FALSE(d.received_data_before_response());
       EXPECT_EQ(uploadBytes, d.data_received());
       EXPECT_EQ(memcmp(uploadBytes, d.data_received().c_str(), kMsgSize), 0);
       EXPECT_EQ(d.data_received().compare(uploadBytes), 0);
     }
     delete[] uploadBytes;
   }
 
   void AddChunksToUpload(TestURLRequest* r) {
     r->AppendChunkToUpload("a", 1, false);
     r->AppendChunkToUpload("bcd", 3, false);
     r->AppendChunkToUpload("this is a longer chunk than before.", 35, false);
     r->AppendChunkToUpload("\r\n\r\n", 4, false);
     r->AppendChunkToUpload("0", 1, false);
     r->AppendChunkToUpload("2323", 4, true);
   }
 
   void VerifyReceivedDataMatchesChunks(TestURLRequest* r, TestDelegate* d) {
     // This should match the chunks sent by AddChunksToUpload().
     const char* expected_data =
         "abcdthis is a longer chunk than before.\r\n\r\n02323";
 
     ASSERT_EQ(1, d->response_started_count()) << "request failed: " <<
-        (int) r->status().status() << ", os error: " << r->status().os_error();
+        (int) r->status().status() << ", os error: " << r->status().error();
 
     EXPECT_FALSE(d->received_data_before_response());
 
     ASSERT_EQ(strlen(expected_data), static_cast<size_t>(d->bytes_received()));
     EXPECT_EQ(0, memcmp(d->data_received().c_str(), expected_data,
                         strlen(expected_data)));
   }
 
   TestServer test_server_;
 };
@@ skipping 14 matching lines @@
   TestDelegate d;
   {
     URLRequest r(GURL("https://www.redirect.com/"), &d);
     r.set_context(context);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().os_error());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
     EXPECT_EQ(1, d.response_started_count());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
   }
 }
 
 // This is the same as the previous test, but checks that the network delegate
 // registers the error.
 TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) {
   ASSERT_TRUE(test_server_.Start());
 
   TestNetworkDelegate network_delegate;  // must outlive URLRequest
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext(true));
   context->SetProxyFromString(test_server_.host_port_pair().ToString());
   context->set_network_delegate(&network_delegate);
   context->Init();
 
   TestDelegate d;
   {
     URLRequest r(GURL("https://www.redirect.com/"), &d);
     r.set_context(context);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().os_error());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
     EXPECT_EQ(1, d.response_started_count());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
 
     EXPECT_EQ(1, network_delegate.error_count());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_os_error());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
   }
 }
 
 // Tests that the network delegate can block and cancel a request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
   network_delegate.set_callback_retval(ERR_EMPTY_RESPONSE);
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext(true));
   context->SetProxyFromString(test_server_.host_port_pair().ToString());
   context->set_network_delegate(&network_delegate);
   context->Init();
 
   {
     TestURLRequest r(test_server_.GetURL(""), &d);
     r.set_context(context);
 
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().os_error());
+    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can cancel a request synchronously.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
   network_delegate.set_retval(ERR_EMPTY_RESPONSE);
 
   scoped_refptr<TestURLRequestContext> context(new TestURLRequestContext(true));
   context->SetProxyFromString(test_server_.host_port_pair().ToString());
   context->set_network_delegate(&network_delegate);
   context->Init();
 
   {
     TestURLRequest r(test_server_.GetURL(""), &d);
     r.set_context(context);
 
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().os_error());
+    EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 10 matching lines @@
 
   {
     GURL original_url(test_server_.GetURL("empty.html"));
     TestURLRequest r(original_url, &d);
     r.set_context(context);
 
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(0, r.status().os_error());
+    EXPECT_EQ(0, r.status().error());
     EXPECT_EQ(redirect_url, r.url());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(2U, r.url_chain().size());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // In this unit test, we're using the HTTPTestServer as a proxy server and
@@ skipping 12 matching lines @@
   {
     URLRequest r(GURL("https://www.server-auth.com/"), &d);
     r.set_context(context);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().os_error());
+    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error());
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     TestURLRequest r(test_server_.GetURL(""), &d);
     r.set_context(default_context_);
@@ skipping 72 matching lines @@
       r.set_context(context);
       r.Start();
       EXPECT_TRUE(r.is_pending());
 
       MessageLoop::current()->Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       VLOG(1) << " Received " << d.bytes_received() << " bytes"
               << " status = " << r.status().status()
-              << " os_error = " << r.status().os_error();
+              << " error = " << r.status().error();
       if (test_expect_success[i]) {
         EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status())
             << " Parameter = \"" << test_file << "\"";
       } else {
         EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
-        EXPECT_EQ(-100, r.status().os_error())
+        EXPECT_EQ(-100, r.status().error())
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
 
 TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestServer https_test_server(
@@ skipping 349 matching lines @@
     TestURLRequest r(test_server_.GetURL("echo"), &d);
     r.set_context(default_context_);
     r.set_method("POST");
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
-        (int) r.status().status() << ", os error: " << r.status().os_error();
+        (int) r.status().status() << ", error: " << r.status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_TRUE(d.data_received().empty());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostFileTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
@@ skipping 26 matching lines @@
     int64 longsize;
     ASSERT_EQ(true, file_util::GetFileSize(path, &longsize));
     int size = static_cast<int>(longsize);
     scoped_array<char> buf(new char[size]);
 
     int size_read = static_cast<int>(file_util::ReadFile(path,
         buf.get(), size));
     ASSERT_EQ(size, size_read);
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
-        (int) r.status().status() << ", os error: " << r.status().os_error();
+        (int) r.status().status() << ", error: " << r.status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     ASSERT_EQ(size, d.bytes_received());
     EXPECT_EQ(0, memcmp(d.data_received().c_str(), buf.get(), size));
   }
 }
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 441 matching lines @@
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   TestURLRequest req(test_server_.GetURL(
       "files/redirect-to-file.html"), &d);
   req.set_context(default_context_);
   req.Start();
   MessageLoop::current()->Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().os_error());
+  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().error());
 }
 
 TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   TestURLRequest req(test_server_.GetURL(
       "files/redirect-to-invalid-url.html"), &d);
   req.set_context(default_context_);
   req.Start();
   MessageLoop::current()->Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_INVALID_URL, req.status().os_error());
+  EXPECT_EQ(ERR_INVALID_URL, req.status().error());
 }
 
 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   TestURLRequest req(test_server_.GetURL("echoheader?Referer"), &d);
   req.set_context(default_context_);
   req.set_referrer("http://user:pass@foo.com/");
   req.Start();
@@ skipping 1162 matching lines @@
   TestURLRequest req(GURL("http://example.com"), &d);
   req.set_context(context);
   req.set_method("GET");
 
   req.Start();
   MessageLoop::current()->Run();
 
   // Check we see a failed request.
   EXPECT_FALSE(req.status().is_success());
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().os_error());
+  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error());
 
   EXPECT_EQ(1, network_delegate.error_count());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_os_error());
+  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
   EXPECT_EQ(1, network_delegate.completed_requests());
 }
 
 // Check that it is impossible to change the referrer in the extra headers of
 // an URLRequest.
 TEST_F(URLRequestTest, DoNotOverrideReferrer) {
   TestServer test_server(TestServer::TYPE_HTTP, FilePath());
   ASSERT_TRUE(test_server.Start());
 
   // If extra headers contain referer and the request contains a referer,
@@ skipping 541 matching lines @@
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   // If the net tests are being run with ChromeFrame then we need to allow for
   // the 'chromeframe' suffix which is added to the user agent before the
   // closing parentheses.
   EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true));
 }
 
 }  // namespace net