Revert of Adjust callers and networking delegates in net/ to modified APIs

net/url_request/url_request_unittest.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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ skipping 1098 matching lines @@
   EXPECT_GT(info.size, 0);
   std::string sentinel_output = GetDirectoryListingEntry(
       base::string16(sentinel_name, sentinel_name + strlen(sentinel_name)),
       std::string(sentinel_name),
       false /* is_dir */,
       info.size,
       info.last_modified);
 
   ASSERT_LT(0, d.bytes_received());
   ASSERT_FALSE(d.request_failed());
-  EXPECT_EQ(OK, d.request_status());
+  ASSERT_TRUE(req->status().is_success());
   // Check for the entry generated for the "sentinel" file.
   const std::string& data = d.data_received();
   ASSERT_NE(data.find(sentinel_output), std::string::npos);
 }
 
 TEST_F(URLRequestTest, FileDirRedirectNoCrash) {
   // There is an implicit redirect when loading a file path that matches a
   // directory and does not end with a slash.  Ensure that following such
   // redirects does not crash.  See http://crbug.com/18686.
 
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.Append(kTestFilePath);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       FilePathToFileURL(path), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   ASSERT_EQ(1, d.received_redirect_count());
   ASSERT_LT(0, d.bytes_received());
   ASSERT_FALSE(d.request_failed());
-  EXPECT_EQ(OK, d.request_status());
+  ASSERT_TRUE(req->status().is_success());
 }
 
 #if defined(OS_WIN)
 // Don't accept the url "file:///" on windows. See http://crbug.com/1474.
 TEST_F(URLRequestTest, FileDirRedirectSingleSlash) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
       default_context_.CreateRequest(GURL("file:///"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   ASSERT_EQ(1, d.received_redirect_count());
-  EXPECT_NE(OK, d.request_status());
+  ASSERT_FALSE(req->status().is_success());
 }
 #endif  // defined(OS_WIN)
 
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 TEST_F(URLRequestTest, InvalidUrlTest) {
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         GURL("invalid url"), DEFAULT_PRIORITY, &d));
@@ skipping 441 matching lines @@
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Make sure we can retrieve our specific user data.
   EXPECT_EQ(user_data0, req->GetUserData(nullptr));
   EXPECT_EQ(user_data1, req->GetUserData(&user_data1));
   EXPECT_EQ(user_data2, req->GetUserData(&user_data2));
 
   // Check that we got one good response.
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_TRUE(req->status().is_success());
   EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRedirect) {
   // Intercept the main request and respond with a redirect.
   interceptor()->set_intercept_main_request(true);
   interceptor()->set_main_headers(
@@ skipping 10 matching lines @@
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_intercept_main());
   EXPECT_TRUE(interceptor()->did_intercept_redirect());
 
   // Check that we got one good response.
-  int status = d.request_status();
-  EXPECT_EQ(OK, status);
-  if (status == OK)
+  EXPECT_TRUE(req->status().is_success());
+  if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
 
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptServerError) {
   // Intercept the main request to generate a server error response.
   interceptor()->set_intercept_main_request(true);
@@ skipping 10 matching lines @@
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_intercept_main());
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check that we got one good response.
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_TRUE(req->status().is_success());
   EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptNetworkError) {
   // Intercept the main request to simulate a network error.
   interceptor()->set_simulate_main_network_error(true);
 
   // Intercept that error and respond with an OK response.
   interceptor()->set_intercept_final_response(true);
   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_simulate_error_main());
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check that we received one good response.
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_TRUE(req->status().is_success());
   EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRestartRequired) {
   // Restart the main request.
   interceptor()->set_restart_main_request(true);
 
   // then intercept the new main request and respond with an OK response
   interceptor()->set_intercept_main_request(true);
   interceptor()->set_main_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_main_data(MockURLRequestInterceptor::ok_data());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_restart_main());
   EXPECT_TRUE(interceptor()->did_intercept_main());
 
   // Check that we received one good response.
-  int status = d.request_status();
-  EXPECT_EQ(OK, status);
-  if (status == OK)
+  EXPECT_TRUE(req->status().is_success());
+  if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
 
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelMain) {
   // Intercept the main request and cancel from within the restarted job.
   interceptor()->set_cancel_main_request(true);
 
   // Set up to intercept the final response and override it with an OK response.
   interceptor()->set_intercept_final_response(true);
   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_cancel_main());
   EXPECT_FALSE(interceptor()->did_intercept_final());
 
   // Check that we see a canceled request.
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_FALSE(req->status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelRedirect) {
   // Intercept the main request and respond with a redirect.
   interceptor()->set_intercept_main_request(true);
   interceptor()->set_main_headers(
       MockURLRequestInterceptor::redirect_headers());
   interceptor()->set_main_data(MockURLRequestInterceptor::redirect_data());
 
   // Intercept the redirect and cancel from within that job.
@@ skipping 10 matching lines @@
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_intercept_main());
   EXPECT_TRUE(interceptor()->did_cancel_redirect());
   EXPECT_FALSE(interceptor()->did_intercept_final());
 
   // Check that we see a canceled request.
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_FALSE(req->status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelFinal) {
   // Intercept the main request to simulate a network error.
   interceptor()->set_simulate_main_network_error(true);
 
   // Set up to intercept final the response and cancel from within that job.
   interceptor()->set_cancel_final_request(true);
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_simulate_error_main());
   EXPECT_TRUE(interceptor()->did_cancel_final());
 
   // Check that we see a canceled request.
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_FALSE(req->status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 }
 
 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelInRestart) {
   // Intercept the main request and cancel then restart from within that job.
   interceptor()->set_cancel_then_restart_main_request(true);
 
   // Set up to intercept the final response and override it with an OK response.
   interceptor()->set_intercept_final_response(true);
   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   // Check that the interceptor got called as expected.
   EXPECT_TRUE(interceptor()->did_cancel_then_restart_main());
   EXPECT_FALSE(interceptor()->did_intercept_final());
 
   // Check that we see a canceled request.
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_FALSE(req->status().is_success());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 }
 
 // "Normal" LoadTimingInfo as returned by a job.  Everything is in order, not
 // reused.  |connect_time_flags| is used to indicate if there should be dns
 // or SSL times, and |used_proxy| is used for proxy times.
 LoadTimingInfo NormalLoadTimingInfo(base::TimeTicks now,
                                     int connect_time_flags,
                                     bool used_proxy) {
   LoadTimingInfo load_timing;
   load_timing.socket_log_id = 1;
@@ skipping 289 matching lines @@
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
       context.CreateRequest(GURL("http://example.com"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
 
   req->Start();
   base::RunLoop().Run();
 
   // Check we see a failed request.
+  EXPECT_FALSE(req->status().is_success());
   // The proxy server is not set before failure.
   EXPECT_TRUE(req->proxy_server().IsEmpty());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, d.request_status());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_THAT(req->status().error(), IsError(ERR_PROXY_CONNECTION_FAILED));
 
   EXPECT_EQ(1, network_delegate.error_count());
   EXPECT_THAT(network_delegate.last_error(),
               IsError(ERR_PROXY_CONNECTION_FAILED));
   EXPECT_EQ(1, network_delegate.completed_requests());
 }
 
 // Make sure that NetworkDelegate::NotifyCompleted is called if
 // content is empty.
 TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) {
@@ skipping 832 matching lines @@
   TestDelegate d;
   // Request that just hangs.
   GURL url(URLRequestFailedJob::GetMockHttpUrl(ERR_IO_PENDING));
   std::unique_ptr<URLRequest> r(
       default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
   r->Start();
 
   power_monitor_source->Suspend();
   // Wait for the suspend notification to cause the request to fail.
   base::RunLoop().Run();
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   EXPECT_TRUE(d.request_failed());
   EXPECT_EQ(1, default_network_delegate_.completed_requests());
 
   URLRequestFilter::GetInstance()->ClearHandlers();
 
   // Shouldn't be needed, but just in case.
   power_monitor_source->Resume();
 }
 
 // FixedDateNetworkDelegate swaps out the server's HTTP Date response header
@@ skipping 164 matching lines @@
       req->set_upload(CreateSimpleUploadData(kData));
       HttpRequestHeaders headers;
       headers.SetHeader(HttpRequestHeaders::kContentLength,
                         base::SizeTToString(arraysize(kData) - 1));
       headers.SetHeader(HttpRequestHeaders::kContentType, "text/plain");
       req->SetExtraRequestHeaders(headers);
     }
     req->Start();
     base::RunLoop().Run();
     EXPECT_EQ(redirect_method, req->method());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
+    EXPECT_THAT(req->status().error(), IsOk());
     if (include_data) {
       if (request_method == redirect_method) {
         EXPECT_TRUE(req->extra_request_headers().HasHeader(
             HttpRequestHeaders::kContentLength));
         EXPECT_TRUE(req->extra_request_headers().HasHeader(
             HttpRequestHeaders::kContentType));
         EXPECT_EQ(kData, d.data_received());
       } else {
         EXPECT_FALSE(req->extra_request_headers().HasHeader(
             HttpRequestHeaders::kContentLength));
@@ skipping 68 matching lines @@
           test_server_.GetURL("/echo"), DEFAULT_PRIORITY, &d));
       r->set_method(method.c_str());
 
       r->set_upload(CreateSimpleUploadData(uploadBytes));
 
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
-      ASSERT_EQ(1, d.response_started_count()) << "request failed. Error: "
-                                               << d.request_status();
+      ASSERT_EQ(1, d.response_started_count())
+          << "request failed: " << r->status().status()
+          << ", os error: " << r->status().error();
 
       EXPECT_FALSE(d.received_data_before_response());
       EXPECT_EQ(uploadBytes, d.data_received());
     }
     delete[] uploadBytes;
   }
 
   bool DoManyCookiesRequest(int num_cookies) {
     TestDelegate d;
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         test_server_.GetURL("/set-many-cookies?" +
                             base::IntToString(num_cookies)),
         DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    if (d.request_status() != OK) {
-      EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, d.request_status());
-      return false;
-    }
+    bool is_success = r->status().is_success();
 
-    return true;
+    if (!is_success)
+      EXPECT_TRUE(r->status().error() == ERR_RESPONSE_HEADERS_TOO_BIG);
+
+    return is_success;
   }
 
   LocalHttpTestServer* http_test_server() { return &test_server_; }
 
  private:
   LocalHttpTestServer test_server_;
 };
 
 namespace {
 
@@ skipping 83 matching lines @@
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         https_test_server.GetURL("tokbind-ekm"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     HttpRequestHeaders headers;
     std::string token_binding_header, token_binding_message;
     EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
     EXPECT_TRUE(headers.GetHeader(HttpRequestHeaders::kTokenBinding,
                                   &token_binding_header));
     EXPECT_TRUE(base::Base64UrlDecode(
         token_binding_header, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
         &token_binding_message));
     std::vector<TokenBinding> token_bindings;
@@ skipping 22 matching lines @@
   {
     GURL redirect_url =
         https_test_server.GetURL("forward-tokbind?/tokbind-ekm");
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     HttpRequestHeaders headers;
     std::string token_binding_header, token_binding_message;
     EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
     EXPECT_TRUE(headers.GetHeader(HttpRequestHeaders::kTokenBinding,
                                   &token_binding_header));
     EXPECT_TRUE(base::Base64UrlDecode(
         token_binding_header, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
         &token_binding_message));
     std::vector<TokenBinding> token_bindings;
@@ skipping 32 matching lines @@
   {
     GURL redirect_url = http_server.GetURL(
         "forward-tokbind?" + https_test_server.GetURL("tokbind-ekm").spec());
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     HttpRequestHeaders headers;
     std::string token_binding_header, token_binding_message;
     EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
     EXPECT_TRUE(headers.GetHeader(HttpRequestHeaders::kTokenBinding,
                                   &token_binding_header));
     EXPECT_TRUE(base::Base64UrlDecode(
         token_binding_header, base::Base64UrlDecodePolicy::REQUIRE_PADDING,
         &token_binding_message));
     std::vector<TokenBinding> token_bindings;
@@ skipping 30 matching lines @@
   {
     GURL redirect_url = token_binding_test_server.GetURL(
         "forward-tokbind?" + https_test_server.GetURL("tokbind-ekm").spec());
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     HttpRequestHeaders headers;
     std::string token_binding_header, token_binding_message;
     EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
     EXPECT_FALSE(headers.GetHeader(HttpRequestHeaders::kTokenBinding,
                                    &token_binding_header));
   }
 }
 #endif  // !defined(OS_ANDROID)
 #endif  // !defined(OS_IOS)
@@ skipping 13 matching lines @@
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_TUNNEL_CONNECTION_FAILED));
     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(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContextWithProxy context(
       http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
+    EXPECT_THAT(r->status().error(), IsError(ERR_TUNNEL_CONNECTION_FAILED));
     EXPECT_EQ(1, d.response_started_count());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
 
     EXPECT_EQ(1, network_delegate.error_count());
     EXPECT_THAT(network_delegate.last_error(),
                 IsError(ERR_TUNNEL_CONNECTION_FAILED));
   }
 }
 
 // Tests that we can block and asynchronously return OK in various stages.
@@ skipping 25 matching lines @@
 
     r->Start();
     for (size_t i = 0; i < blocking_stages_length; ++i) {
       base::RunLoop().Run();
       EXPECT_EQ(blocking_stages[i],
                 network_delegate.stage_blocked_for_callback());
       network_delegate.DoCallback(OK);
     }
     base::RunLoop().Run();
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     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 cancel a request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::AUTO_CALLBACK);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
   network_delegate.set_retval(ERR_EMPTY_RESPONSE);
 
   TestURLRequestContextWithProxy context(
       http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before cancellation.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_EMPTY_RESPONSE, d.request_status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_EMPTY_RESPONSE));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Helper function for NetworkDelegateCancelRequestAsynchronously and
 // NetworkDelegateCancelRequestSynchronously. Sets up a blocking network
 // delegate operating in |block_mode| and a request for |url|. It blocks the
 // request in |stage| and cancels it with ERR_BLOCKED_BY_CLIENT.
 void NetworkDelegateCancelRequest(BlockingNetworkDelegate::BlockMode block_mode,
                                   BlockingNetworkDelegate::Stage stage,
                                   const GURL& url) {
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(block_mode);
   network_delegate.set_retval(ERR_BLOCKED_BY_CLIENT);
   network_delegate.set_block_on(stage);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before cancellation.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, d.request_status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_BLOCKED_BY_CLIENT));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // The following 3 tests check that the network delegate can cancel a request
 // synchronously in various stages of the request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) {
   ASSERT_TRUE(http_test_server()->Start());
@@ skipping 58 matching lines @@
     GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     // Quit after hitting the redirect, so can check the headers.
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     // Check headers from URLRequestJob.
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(307, r->GetResponseCode());
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(1, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
 
-    EXPECT_EQ(OK, d.request_status());
+    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());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
@@ skipping 14 matching lines @@
     GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     // Quit after hitting the redirect, so can check the headers.
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     // Check headers from URLRequestJob.
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(307, r->GetResponseCode());
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(1, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
-    EXPECT_EQ(OK, d.request_status());
+    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());
 }
 
 // Tests that redirects caused by the network delegate preserve POST data.
@@ skipping 23 matching lines @@
     headers.SetHeader(HttpRequestHeaders::kContentLength,
                       base::SizeTToString(arraysize(kData) - 1));
     r->SetExtraRequestHeaders(headers);
 
     // Quit after hitting the redirect, so can check the headers.
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     // Check headers from URLRequestJob.
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(307, r->GetResponseCode());
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    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("POST", r->method());
     EXPECT_EQ(kData, d.data_received());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
@@ skipping 14 matching lines @@
       http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
     GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(2, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(2, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
@@ skipping 14 matching lines @@
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 TEST_F(URLRequestTestHTTP,
     NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
@@ skipping 16 matching lines @@
     r->Start();
 
     {
       HttpRequestHeaders headers;
       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_FALSE(headers.HasHeader("Authorization"));
     }
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     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 synchronously complete OnAuthRequired
 // by setting credentials.
@@ skipping 13 matching lines @@
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Same as above, but also tests that GetFullRequestHeaders returns the proper
 // headers (for the first or second request) when called at the proper times.
@@ skipping 14 matching lines @@
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
 
     {
       HttpRequestHeaders headers;
       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
       EXPECT_TRUE(headers.HasHeader("Authorization"));
     }
@@ skipping 17 matching lines @@
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(401, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     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 asynchronously complete OnAuthRequired
 // by taking no action. This indicates that the NetworkDelegate does not want
@@ skipping 13 matching lines @@
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     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 asynchronously complete OnAuthRequired
 // by setting credentials.
@@ skipping 14 matching lines @@
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(0, r->status().error());
+
     EXPECT_EQ(200, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     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 asynchronously complete OnAuthRequired
 // by cancelling authentication.
@@ skipping 11 matching lines @@
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(http_test_server()->GetURL("/auth-basic"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(401, r->GetResponseCode());
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
@@ skipping 16 matching lines @@
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
-    EXPECT_EQ(1, network_delegate.canceled_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_ABORTED));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 2: Request is cancelled while waiting for OnBeforeStartTransaction
 // callback.
@@ skipping 16 matching lines @@
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
-    EXPECT_EQ(1, network_delegate.canceled_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_ABORTED));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) {
@@ skipping 14 matching lines @@
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
-    EXPECT_EQ(1, network_delegate.canceled_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_ABORTED));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 4: Request is cancelled while waiting for OnAuthRequired callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) {
@@ skipping 14 matching lines @@
 
     r->Start();
     base::RunLoop().Run();
     EXPECT_EQ(BlockingNetworkDelegate::ON_AUTH_REQUIRED,
               network_delegate.stage_blocked_for_callback());
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r->Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
-    EXPECT_EQ(1, network_delegate.canceled_requests());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_ABORTED));
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 namespace {
 
 std::unique_ptr<test_server::HttpResponse> HandleServerAuthConnect(
     const test_server::HttpRequest& request) {
@@ skipping 28 matching lines @@
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.server-auth.com/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     // The proxy server is not set before failure.
     EXPECT_TRUE(r->proxy_server().IsEmpty());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_TUNNEL_CONNECTION_FAILED));
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
@@ skipping 181 matching lines @@
       std::unique_ptr<URLRequest> r(context.CreateRequest(
           test_server.GetURL(test_file), DEFAULT_PRIORITY, &d));
       r->Start();
       EXPECT_TRUE(r->is_pending());
 
       base::RunLoop().Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       VLOG(1) << " Received " << d.bytes_received() << " bytes"
-              << " error = " << d.request_status();
+              << " status = " << r->status().status()
+              << " error = " << r->status().error();
       if (test_expect_success[i]) {
-        EXPECT_EQ(OK, d.request_status()) << " Parameter = \"" << test_file
-                                          << "\"";
+        EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status())
+            << " Parameter = \"" << test_file << "\"";
         if (test_parameters[i] == 'S') {
           // When content length is smaller than both compressed length and
           // uncompressed length, HttpStreamParser might not read the full
           // response body.
           continue;
         }
         EXPECT_EQ(expected_content, d.data_received());
       } else {
-        EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, d.request_status())
+        EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+        EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r->status().error())
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
 #endif  // !defined(OS_IOS)
 
 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) {
   ASSERT_TRUE(http_test_server()->Start());
 
@@ skipping 363 matching lines @@
     AsyncDelegateLogger::Run(
         r.get(),
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_IDLE,
         base::Bind(&URLRequest::Start, base::Unretained(r.get())));
 
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   size_t log_position = ExpectLogContainsSomewhereAfter(
       entries,
       0,
       NetLog::TYPE_DELEGATE_INFO,
       NetLog::PHASE_BEGIN);
 
@@ skipping 20 matching lines @@
         context.CreateRequest(http_test_server()->GetURL("/simple.html"),
                               DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   for (size_t i = 0; i < 3; ++i) {
     log_position = ExpectLogContainsSomewhereAfter(
@@ skipping 31 matching lines @@
         http_test_server()->GetURL("/server-redirect?simple.html"),
         DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(2, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate logged information in OnBeforeURLRequest,
   // OnBeforeStartTransaction, and OnHeadersReceived.
@@ skipping 56 matching lines @@
         context.CreateRequest(http_test_server()->GetURL("/auth-basic"),
                               DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
     EXPECT_EQ(base::string16(), load_state.param);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate should have logged information in OnBeforeURLRequest,
   // OnBeforeStartTransaction, OnHeadersReceived, OnAuthRequired, and then again
@@ skipping 42 matching lines @@
     // the possibility of multiple reads being combined in the unlikely event
     // that it occurs.
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         test_server.GetURL("/chunked?waitBetweenChunks=20"), DEFAULT_PRIORITY,
         &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
 
   size_t log_position = 0;
 
   // The delegate info should only have been logged on header complete.  Other
   // times it should silently be ignored.
   log_position =
@@ skipping 30 matching lines @@
 
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         http_test_server()->GetURL("/server-redirect?simple.html"),
         DEFAULT_PRIORITY, &request_delegate));
     LoadStateWithParam load_state = r->GetLoadState();
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r->GetResponseCode());
-    EXPECT_EQ(OK, request_delegate.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
 
   // Delegate info should only have been logged in OnReceivedRedirect and
   // OnResponseStarted.
   size_t log_position = 0;
   for (int i = 0; i < 2; ++i) {
     log_position = ExpectLogContainsSomewhereAfter(
@@ skipping 36 matching lines @@
     context.set_net_log(&net_log);
     context.Init();
 
     {
       std::unique_ptr<URLRequest> r(context.CreateRequest(
           http_test_server()->GetURL("/server-redirect?simple.html"),
           DEFAULT_PRIORITY, &request_delegate));
       LoadStateWithParam load_state = r->GetLoadState();
       r->Start();
       base::RunLoop().Run();
-      EXPECT_EQ(ERR_ABORTED, request_delegate.request_status());
+      EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     }
 
     TestNetLogEntry::List entries;
     net_log.GetEntries(&entries);
 
     // Delegate info is always logged in both OnReceivedRedirect and
     // OnResponseStarted.  In the CANCEL_ON_RECEIVED_REDIRECT, the
     // OnResponseStarted delegate call is after cancellation, but logging is
     // still currently supported in that call.
     size_t log_position = 0;
@@ skipping 126 matching lines @@
     d.set_cancel_in_response_started(true);
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(ERR_ABORTED, d.request_status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest3) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     d.set_cancel_in_received_data(true);
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     // There is no guarantee about how much data was received
     // before the cancel was issued.  It could have been 0 bytes,
     // or it could have been all the bytes.
     // EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(ERR_ABORTED, d.request_status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelTest4) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
@@ skipping 19 matching lines @@
 TEST_F(URLRequestTestHTTP, CancelTest5) {
   ASSERT_TRUE(http_test_server()->Start());
 
   // populate cache
   {
     TestDelegate d;
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
     r->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   }
 
   // cancel read from cache (see bug 990242)
   {
     TestDelegate d;
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
     r->Start();
     r->Cancel();
     base::RunLoop().Run();
 
-    EXPECT_EQ(ERR_ABORTED, d.request_status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostTest) {
   ASSERT_TRUE(http_test_server()->Start());
   HTTPUploadDataOperationTest("POST");
 }
@@ skipping 10 matching lines @@
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/echo"), DEFAULT_PRIORITY, &d));
     r->set_method("POST");
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    ASSERT_EQ(1, d.response_started_count()) << "request failed. Error: "
-                                             << d.request_status();
+    ASSERT_EQ(1, d.response_started_count())
+        << "request failed: " << 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(http_test_server()->Start());
 
   TestDelegate d;
@@ skipping 24 matching lines @@
     base::RunLoop().Run();
 
     int64_t size64 = 0;
     ASSERT_EQ(true, base::GetFileSize(path, &size64));
     ASSERT_LE(size64, std::numeric_limits<int>::max());
     int size = static_cast<int>(size64);
     std::unique_ptr<char[]> buf(new char[size]);
 
     ASSERT_EQ(size, base::ReadFile(path, buf.get(), size));
 
-    ASSERT_EQ(1, d.response_started_count()) << "request failed. Error: "
-                                             << d.request_status();
+    ASSERT_EQ(1, d.response_started_count())
+        << "request failed: " << r->status().status()
+        << ", error: " << r->status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     EXPECT_EQ(size, d.bytes_received());
     EXPECT_EQ(std::string(&buf[0], size), d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostUnreadableFileTest) {
   ASSERT_TRUE(http_test_server()->Start());
@@ skipping 15 matching lines @@
         new ElementsUploadDataStream(std::move(element_readers), 0)));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.request_failed());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
-    EXPECT_EQ(ERR_FILE_NOT_FOUND, d.request_status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_FILE_NOT_FOUND));
   }
 }
 
 namespace {
 
 // Adds a standard set of data to an upload for chunked upload integration
 // tests.
 void AddDataToUpload(ChunkedUploadDataStream::Writer* writer) {
   writer->AppendData("a", 1, false);
   writer->AppendData("bcd", 3, false);
   writer->AppendData("this is a longer chunk than before.", 35, false);
   writer->AppendData("\r\n\r\n", 4, false);
   writer->AppendData("0", 1, false);
   writer->AppendData("2323", 4, true);
 }
 
 // Checks that the upload data added in AddChunksToUpload() was echoed back from
 // the server.
 void VerifyReceivedDataMatchesChunks(URLRequest* r, TestDelegate* d) {
   // This should match the chunks sent by AddChunksToUpload().
   const std::string expected_data =
       "abcdthis is a longer chunk than before.\r\n\r\n02323";
 
-  ASSERT_EQ(1, d->response_started_count()) << "request failed. Error: "
-                                            << d->request_status();
+  ASSERT_EQ(1, d->response_started_count())
+      << "request failed: " << r->status().status()
+      << ", os error: " << r->status().error();
 
   EXPECT_FALSE(d->received_data_before_response());
 
   EXPECT_EQ(expected_data.size(), static_cast<size_t>(d->bytes_received()));
   EXPECT_EQ(expected_data, d->data_received());
 }
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
@@ skipping 731 matching lines @@
 TEST_F(URLRequestTestHTTP, RestrictFileRedirects) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/redirect-to-file.html"), DEFAULT_PRIORITY,
       &d));
   req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, d.request_status());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_THAT(req->status().error(), IsError(ERR_UNSAFE_REDIRECT));
 }
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 TEST_F(URLRequestTestHTTP, RestrictDataRedirects) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/redirect-to-data.html"), DEFAULT_PRIORITY,
       &d));
   req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, d.request_status());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_THAT(req->status().error(), IsError(ERR_UNSAFE_REDIRECT));
 }
 
 TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/redirect-to-invalid-url.html"),
       DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(ERR_INVALID_URL, d.request_status());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_THAT(req->status().error(), IsError(ERR_INVALID_URL));
 }
 
 // Make sure redirects are cached, despite not reading their bodies.
 TEST_F(URLRequestTestHTTP, CacheRedirect) {
   ASSERT_TRUE(http_test_server()->Start());
   GURL redirect_url =
       http_test_server()->GetURL("/redirect302-to-echo-cacheable");
 
   {
     TestDelegate d;
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(http_test_server()->GetURL("/echo"), req->url());
   }
 
   {
     TestDelegate d;
     d.set_quit_on_redirect(true);
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(0, d.response_started_count());
     EXPECT_TRUE(req->was_cached());
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(1, d.response_started_count());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(http_test_server()->GetURL("/echo"), req->url());
   }
 }
 
 // Make sure a request isn't cached when a NetworkDelegate forces a redirect
 // when the headers are read, since the body won't have been read.
 TEST_F(URLRequestTestHTTP, NoCacheOnNetworkDelegateRedirect) {
   ASSERT_TRUE(http_test_server()->Start());
   // URL that is normally cached.
   GURL initial_url = http_test_server()->GetURL("/cachetime");
 
   {
     // Set up the TestNetworkDelegate tp force a redirect.
     GURL redirect_to_url = http_test_server()->GetURL("/echo");
     default_network_delegate_.set_redirect_on_headers_received_url(
         redirect_to_url);
 
     TestDelegate d;
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(initial_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(redirect_to_url, req->url());
   }
 
   {
     TestDelegate d;
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(initial_url, DEFAULT_PRIORITY, &d));
     req->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
     EXPECT_FALSE(req->was_cached());
     EXPECT_EQ(0, d.received_redirect_count());
     EXPECT_EQ(initial_url, req->url());
   }
 }
 
 // Tests that redirection to an unsafe URL is allowed when it has been marked as
 // safe.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL unsafe_url("data:text/html,this-is-considered-an-unsafe-url");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/whatever"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+
     EXPECT_EQ(2U, r->url_chain().size());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(unsafe_url, r->url());
     EXPECT_EQ("this-is-considered-an-unsafe-url", d.data_received());
   }
 }
 
 // Tests that a redirect to a different unsafe URL is blocked, even after adding
 // some other URL to the whitelist.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToDifferentUnsafeURL) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL unsafe_url("data:text/html,something");
   GURL different_unsafe_url("data:text/html,something-else");
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(
       different_unsafe_url);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/whatever"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
-    EXPECT_EQ(ERR_UNSAFE_REDIRECT, d.request_status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_UNSAFE_REDIRECT));
   }
 }
 
 // Redirects from an URL with fragment to an unsafe URL with fragment should
 // be allowed, and the reference fragment of the target URL should be preserved.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectWithDifferentReferenceFragment) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL original_url(http_test_server()->GetURL("/original#fragment1"));
   GURL unsafe_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
   GURL expected_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
 
   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, but it does not match the
 // redirect target, then do not prevent the reference fragment from being added.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL original_url(http_test_server()->GetURL("/original#expected-fragment"));
   GURL unsafe_url("data:text/html,this-url-does-not-match-redirect-url");
   GURL redirect_url(http_test_server()->GetURL("/target"));
   GURL expected_redirect_url(
       http_test_server()->GetURL("/target#expected-fragment"));
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_redirect_url, r->url());
   }
 }
 
 // When a delegate has specified a safe redirect URL, assume that the redirect
 // URL should not be changed. In particular, the reference fragment should not
 // be modified.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL original_url(
       http_test_server()->GetURL("/original#should-not-be-appended"));
   GURL redirect_url("data:text/html,expect-no-reference-fragment");
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(redirect_url);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(redirect_url, r->url());
   }
 }
 
 // When a URLRequestRedirectJob is created, the redirection must be followed and
 // the reference fragment of the target URL must not be modified.
 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL original_url(
       http_test_server()->GetURL("/original#should-not-be-appended"));
   GURL redirect_url(http_test_server()->GetURL("/echo"));
 
   TestDelegate d;
   std::unique_ptr<URLRequest> r(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       r.get(), &default_network_delegate_, redirect_url,
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason"));
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   r->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+  EXPECT_THAT(r->status().error(), IsOk());
   EXPECT_EQ(original_url, r->original_url());
   EXPECT_EQ(redirect_url, r->url());
 }
 
 TEST_F(URLRequestTestHTTP, UnsupportedReferrerScheme) {
   ASSERT_TRUE(http_test_server()->Start());
 
   const std::string referrer("foobar://totally.legit.referrer");
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
@@ skipping 53 matching lines @@
     d.set_cancel_in_received_redirect(true);
     std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
         http_test_server()->GetURL("/redirect-test.html"), DEFAULT_PRIORITY,
         &d));
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(ERR_ABORTED, d.request_status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     d.set_quit_on_redirect(true);
     GURL test_url(http_test_server()->GetURL("/redirect-test.html"));
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
@@ skipping 20 matching lines @@
     d.ClearFullRequestHeaders();
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     GURL target_url(http_test_server()->GetURL("/with-headers.html"));
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), target_url);
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
@@ skipping 12 matching lines @@
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     req->Cancel();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(ERR_ABORTED, d.request_status());
+    EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, VaryHeader) {
   ASSERT_TRUE(http_test_server()->Start());
 
   // Populate the cache.
   {
     TestDelegate d;
     std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
@@ skipping 357 matching lines @@
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   const GURL url = http_test_server()->GetURL("/308-without-location-header");
 
   std::unique_ptr<URLRequest> request(
       default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
 
   request->Start();
   base::RunLoop().Run();
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_THAT(request->status().error(), IsOk());
   EXPECT_EQ(0, d.received_redirect_count());
   EXPECT_EQ(308, request->response_headers()->response_code());
   EXPECT_EQ("This is not a redirect.", d.data_received());
 }
 
 TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL original_url(
       http_test_server()->GetURL("/redirect302-to-echo#fragment"));
   GURL expected_url(http_test_server()->GetURL("/echo#fragment"));
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(expected_url, r->url());
   }
 }
 
 TEST_F(URLRequestTestHTTP, RedirectPreserveFirstPartyURL) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL url(http_test_server()->GetURL("/redirect302-to-echo"));
   GURL first_party_url("http://example.com");
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->set_first_party_for_cookies(first_party_url);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(first_party_url, r->first_party_for_cookies());
   }
 }
 
 TEST_F(URLRequestTestHTTP, RedirectUpdateFirstPartyURL) {
   ASSERT_TRUE(http_test_server()->Start());
 
   GURL url(http_test_server()->GetURL("/redirect302-to-echo"));
   GURL original_first_party_url("http://example.com");
   GURL expected_first_party_url(http_test_server()->GetURL("/echo"));
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->set_first_party_for_cookies(original_first_party_url);
     r->set_first_party_url_policy(
         URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_THAT(r->status().error(), IsOk());
     EXPECT_EQ(expected_first_party_url, r->first_party_for_cookies());
   }
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
   ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
@@ skipping 269 matching lines @@
   context.set_http_transaction_factory(&http_cache);
   context.Init();
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
       context.CreateRequest(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
-  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, d.request_status());
+  EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
+  EXPECT_THAT(req->status().error(), IsError(ERR_NETWORK_IO_SUSPENDED));
 }
 
 namespace {
 
 // HttpTransactionFactory that synchronously fails to create transactions.
 class FailingHttpTransactionFactory : public HttpTransactionFactory {
  public:
   explicit FailingHttpTransactionFactory(HttpNetworkSession* network_session)
       : network_session_(network_session) {}
 
@@ skipping 39 matching lines @@
   // try to create an HttpNetworkTransaction synchronously on start).
   req->SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
   req->Start();
   req->Cancel();
   base::RunLoop().Run();
   // Run pending error task, if there is one.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(d.request_failed());
   EXPECT_EQ(1, d.response_started_count());
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
 
   // NetworkDelegate should see the cancellation, but not the error.
   EXPECT_EQ(1, default_network_delegate()->canceled_requests());
   EXPECT_EQ(0, default_network_delegate()->error_count());
 }
 
 TEST_F(URLRequestTestHTTP, NetworkAccessedSetOnNetworkRequest) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
@@ skipping 10 matching lines @@
 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnCachedResponse) {
   ASSERT_TRUE(http_test_server()->Start());
 
   // Populate the cache.
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/cachetime"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   EXPECT_TRUE(req->response_info().network_accessed);
   EXPECT_FALSE(req->response_info().was_cached);
 
   req = default_context_.CreateRequest(http_test_server()->GetURL("/cachetime"),
                                        DEFAULT_PRIORITY, &d);
   req->Start();
   base::RunLoop().Run();
 
-  EXPECT_EQ(OK, d.request_status());
+  EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
   EXPECT_FALSE(req->response_info().network_accessed);
   EXPECT_TRUE(req->response_info().was_cached);
 }
 
 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnLoadOnlyFromCache) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   GURL test_url(http_test_server()->GetURL("/"));
   std::unique_ptr<URLRequest> req(
@@ skipping 61 matching lines @@
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       http_test_server()->GetURL("/redirect-test.html"), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_redirect());
   // Check we got one good response
-  int status = d.request_status();
-  EXPECT_EQ(OK, status);
-  if (status == OK)
+  EXPECT_TRUE(req->status().is_success());
+  if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
 
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(1, default_network_delegate()->before_start_transaction_count());
   EXPECT_EQ(1, default_network_delegate()->headers_received_count());
 }
@@ skipping 12 matching lines @@
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       http_test_server()->GetURL("/two-content-lengths.html"), DEFAULT_PRIORITY,
       &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check we received one good response.
-  int status = d.request_status();
-  EXPECT_EQ(OK, status);
-  if (status == OK)
+  EXPECT_TRUE(req->status().is_success());
+  if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(1, default_network_delegate()->before_start_transaction_count());
   EXPECT_EQ(0, default_network_delegate()->headers_received_count());
 }
 
@@ skipping 10 matching lines @@
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context().CreateRequest(
       http_test_server()->GetURL("/simple.html"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
   req->Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(interceptor()->did_intercept_final());
 
   // Check we received one good response.
-  int status = d.request_status();
-  EXPECT_EQ(OK, status);
-  if (status == OK)
+  EXPECT_TRUE(req->status().is_success());
+  if (req->status().is_success())
     EXPECT_EQ(200, req->response_headers()->response_code());
   EXPECT_EQ("hello", d.data_received());
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(0, d.received_redirect_count());
 
   EXPECT_EQ(1, default_network_delegate()->created_requests());
   EXPECT_EQ(2, default_network_delegate()->before_start_transaction_count());
   EXPECT_EQ(2, default_network_delegate()->headers_received_count());
 }
 
@@ skipping 49 matching lines @@
     std::unique_ptr<URLRequest> req(
         default_context_.CreateRequest(origin_url, DEFAULT_PRIORITY, &d));
     req->set_referrer_policy(policy);
     req->SetReferrer(referrer.spec());
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(destination_url, req->url());
-    EXPECT_EQ(OK, d.request_status());
+    EXPECT_TRUE(req->status().is_success());
     EXPECT_EQ(200, req->response_headers()->response_code());
 
     EXPECT_EQ(expected.spec(), req->referrer());
     if (expected.is_empty())
       EXPECT_EQ("None", d.data_received());
     else
       EXPECT_EQ(expected.spec(), d.data_received());
   }
 
   EmbeddedTestServer* origin_server() const { return origin_server_.get(); }
@@ skipping 502 matching lines @@
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         test_server.GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
-    EXPECT_EQ(ERR_SSL_OBSOLETE_CIPHER, d.request_status());
+    EXPECT_FALSE(r->status().is_success());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_SSL_OBSOLETE_CIPHER));
   }
 }
 
 namespace {
 
 class SSLClientAuthTestDelegate : public TestDelegate {
  public:
   SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
   }
   void OnCertificateRequested(URLRequest* request,
@@ skipping 239 matching lines @@
     EXPECT_EQ(1, delegate_.response_started_count());
     EXPECT_NE(0, delegate_.bytes_received());
     EXPECT_EQ(version, SSLConnectionStatusToVersion(
         request_->ssl_info().connection_status));
     EXPECT_TRUE(request_->ssl_info().connection_status &
                 SSL_CONNECTION_VERSION_FALLBACK);
   }
 
   void ExpectFailure(int error) {
     EXPECT_EQ(1, delegate_.response_started_count());
-    EXPECT_EQ(error, delegate_.request_status());
+    EXPECT_FALSE(request_->status().is_success());
+    EXPECT_EQ(URLRequestStatus::FAILED, request_->status().status());
+    EXPECT_EQ(error, request_->status().error());
   }
 
  private:
   TestDelegate delegate_;
   TestURLRequestContext context_;
   std::unique_ptr<URLRequest> request_;
 };
 
 // Tests the TLS 1.0 fallback doesn't happen.
 TEST_F(HTTPSFallbackTest, TLSv1NoFallback) {
@@ skipping 1091 matching lines @@
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
-    EXPECT_EQ(ERR_UNSAFE_PORT, d.request_status());
+    EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
+    EXPECT_THAT(r->status().error(), IsError(ERR_UNSAFE_PORT));
   }
 }
 
 TEST_F(URLRequestTestFTP, FTPDirectoryListing) {
   ASSERT_TRUE(ftp_test_server_.Start());
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         ftp_test_server_.GetURL("/"), DEFAULT_PRIORITY, &d));
@@ skipping 293 matching lines @@
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       req.get(), &default_network_delegate_,
       GURL("http://this-should-never-be-navigated-to/"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Jumbo shrimp"));
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(ERR_ABORTED, d.request_status());
+  EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net