Refactor net tests to use GMock matchers for checking net::Error results

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 75 matching lines @@
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/ssl/token_binding.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
+#include "net/test/gtest_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/test_data_directory.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_http_job.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if !defined(DISABLE_FILE_SUPPORT)
 #include "net/base/filename_util.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/url_request_file_dir_job.h"
 #endif
 
 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 #include "net/ftp/ftp_network_layer.h"
 #include "net/url_request/ftp_protocol_handler.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #endif
 
+using net::test::IsError;
+using net::test::IsOk;
+
 using base::ASCIIToUTF16;
 using base::Time;
 using std::string;
 
 namespace net {
 
 namespace {
 
 const base::string16 kChrome(ASCIIToUTF16("chrome"));
 const base::string16 kSecret(ASCIIToUTF16("secret"));
@@ skipping 1983 matching lines @@
   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(URLRequestStatus::FAILED, req->status().status());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req->status().error());
+  EXPECT_THAT(req->status().error(), IsError(ERR_PROXY_CONNECTION_FAILED));
 
   EXPECT_EQ(1, network_delegate.error_count());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
+  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) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
       default_context_.CreateRequest(GURL("data:,"), DEFAULT_PRIORITY, &d));
   req->Start();
@@ skipping 1014 matching lines @@
       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(URLRequestStatus::SUCCESS, req->status().status());
-    EXPECT_EQ(OK, req->status().error());
+    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 383 matching lines @@
     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, r->status().error());
+    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_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
+    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());
 
     EXPECT_EQ(1, network_delegate.error_count());
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
+    EXPECT_THAT(network_delegate.last_error(),
+                IsError(ERR_TUNNEL_CONNECTION_FAILED));
   }
 }
 
 // Tests that we can block and asynchronously return OK in various stages.
 TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) {
   static const BlockingNetworkDelegate::Stage blocking_stages[] = {
     BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
     BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
     BlockingNetworkDelegate::ON_HEADERS_RECEIVED
   };
@@ skipping 49 matching lines @@
   {
     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, r->status().error());
+    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.
@@ skipping 12 matching lines @@
   {
     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, r->status().error());
+    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 231 matching lines @@
     base::RunLoop().Run();
 
     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, r->status().error());
+    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 163 matching lines @@
   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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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 84 matching lines @@
   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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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 17 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(URLRequestStatus::CANCELED, r->status().status());
-    EXPECT_EQ(ERR_ABORTED, r->status().error());
+    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 17 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(URLRequestStatus::CANCELED, r->status().status());
-    EXPECT_EQ(ERR_ABORTED, r->status().error());
+    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 15 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(URLRequestStatus::CANCELED, r->status().status());
-    EXPECT_EQ(ERR_ABORTED, r->status().error());
+    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 15 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(URLRequestStatus::CANCELED, r->status().status());
-    EXPECT_EQ(ERR_ABORTED, r->status().error());
+    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 31 matching lines @@
         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, r->status().error());
+    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 1292 matching lines @@
 
     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(URLRequestStatus::FAILED, r->status().status());
-    EXPECT_EQ(ERR_FILE_NOT_FOUND, r->status().error());
+    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);
@@ skipping 773 matching lines @@
   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(URLRequestStatus::FAILED, req->status().status());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
+  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(URLRequestStatus::FAILED, req->status().status());
-  EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
+  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(URLRequestStatus::FAILED, req->status().status());
-  EXPECT_EQ(ERR_INVALID_URL, req->status().error());
+  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;
@@ skipping 77 matching lines @@
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         http_test_server()->GetURL("/whatever"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
 
     EXPECT_EQ(2U, r->url_chain().size());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::FAILED, r->status().status());
-    EXPECT_EQ(ERR_UNSAFE_REDIRECT, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-  EXPECT_EQ(OK, r->status().error());
+  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 620 matching lines @@
 
   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(URLRequestStatus::SUCCESS, request->status().status());
-  EXPECT_EQ(OK, request->status().error());
+  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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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(URLRequestStatus::SUCCESS, r->status().status());
-    EXPECT_EQ(OK, r->status().error());
+    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 270 matching lines @@
   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(URLRequestStatus::FAILED, req->status().status());
-  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
+  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 823 matching lines @@
         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_FALSE(r->status().is_success());
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
-    EXPECT_EQ(ERR_SSL_OBSOLETE_CIPHER, r->status().error());
+    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 967 matching lines @@
   {
     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(URLRequestStatus::FAILED, r->status().status());
-    EXPECT_EQ(ERR_UNSAFE_PORT, r->status().error());
+    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 317 matching lines @@
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net