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

net/dns/host_resolver_impl_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 "net/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 15 matching lines @@
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/test_net_log.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 const size_t kMaxJobs = 10u;
 const size_t kMaxRetryAttempts = 4u;
 
 HostResolver::Options DefaultOptions() {
   HostResolver::Options options;
   options.max_concurrent_resolves = kMaxJobs;
@@ skipping 179 matching lines @@
     DCHECK(!handle_);
     list_ = AddressList();
     result_ = resolver_->Resolve(
         info_,
         priority_,
         &list_,
         base::Bind(&Request::OnComplete, base::Unretained(this)),
         &handle_,
         BoundNetLog());
     if (!list_.empty())
-      EXPECT_EQ(OK, result_);
+      EXPECT_THAT(result_, IsOk());
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
     DCHECK(!handle_);
     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
   }
 
   int ResolveStaleFromCache() {
@@ skipping 52 matching lines @@
     closure.Cancel();
     if (did_quit)
       return result_;
     else
       return ERR_UNEXPECTED;
   }
 
  private:
   void OnComplete(int rv) {
     EXPECT_TRUE(pending());
-    EXPECT_EQ(ERR_IO_PENDING, result_);
+    EXPECT_THAT(result_, IsError(ERR_IO_PENDING));
     EXPECT_NE(ERR_IO_PENDING, rv);
     result_ = rv;
     handle_ = NULL;
     if (!list_.empty()) {
-      EXPECT_EQ(OK, result_);
+      EXPECT_THAT(result_, IsOk());
       EXPECT_EQ(info_.port(), list_.front().port());
     }
     if (handler_)
       handler_->Handle(this);
     if (quit_on_complete_) {
       base::MessageLoop::current()->QuitWhenIdle();
       quit_on_complete_ = false;
     }
   }
 
@@ skipping 298 matching lines @@
   std::vector<std::unique_ptr<Request>> requests_;
 
   std::unique_ptr<Handler> handler_;
 };
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);
 
   Request* req = CreateRequest("just.testing", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 
   EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80));
 
   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
 }
 
 // RFC 6761 localhost names should always resolve to loopback.
 TEST_F(HostResolverImplTest, LocalhostLookup) {
   // Add a rule resolving localhost names to a non-loopback IP and test
   // that they still resolves to loopback.
   proc_->AddRuleForAllFamilies("foo.localhost", "192.168.1.42");
   proc_->AddRuleForAllFamilies("localhost", "192.168.1.42");
   proc_->AddRuleForAllFamilies("localhost.", "192.168.1.42");
 
   Request* req0 = CreateRequest("foo.localhost", 80);
-  EXPECT_EQ(OK, req0->Resolve());
+  EXPECT_THAT(req0->Resolve(), IsOk());
   EXPECT_TRUE(req0->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(req0->HasAddress("::1", 80));
 
   Request* req1 = CreateRequest("localhost", 80);
-  EXPECT_EQ(OK, req1->Resolve());
+  EXPECT_THAT(req1->Resolve(), IsOk());
   EXPECT_TRUE(req1->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(req1->HasAddress("::1", 80));
 
   Request* req2 = CreateRequest("localhost.", 80);
-  EXPECT_EQ(OK, req2->Resolve());
+  EXPECT_THAT(req2->Resolve(), IsOk());
   EXPECT_TRUE(req2->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(req2->HasAddress("::1", 80));
 }
 
 TEST_F(HostResolverImplTest, LocalhostIPV4IPV6Lookup) {
   Request* req1 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(OK, req1->Resolve());
+  EXPECT_THAT(req1->Resolve(), IsOk());
   EXPECT_EQ(0u, req1->NumberOfAddresses());
 
   Request* req2 = CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
-  EXPECT_EQ(OK, req2->Resolve());
+  EXPECT_THAT(req2->Resolve(), IsOk());
   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
 
   Request* req3 =
       CreateRequest("localhost6", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
-  EXPECT_EQ(OK, req3->Resolve());
+  EXPECT_THAT(req3->Resolve(), IsOk());
   EXPECT_TRUE(req3->HasOneAddress("::1", 80));
 
   Request* req4 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(OK, req4->Resolve());
+  EXPECT_THAT(req4->Resolve(), IsOk());
   EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));
 
   Request* req5 = CreateRequest("localhost", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
-  EXPECT_EQ(OK, req5->Resolve());
+  EXPECT_THAT(req5->Resolve(), IsOk());
   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
 }
 
 TEST_F(HostResolverImplTest, ResolveIPLiteralWithHostResolverSystemOnly) {
   const char kIpLiteral[] = "178.78.32.1";
   // Add a mapping to tell if the resolver proc was called (if it was called,
   // then the result will be the remapped value. Otherwise it will be the IP
   // literal).
   proc_->AddRuleForAllFamilies(kIpLiteral, "183.45.32.1");
 
   HostResolver::RequestInfo info_bypass(HostPortPair(kIpLiteral, 80));
   info_bypass.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
 
   Request* req = CreateRequest(info_bypass, MEDIUM);
-  EXPECT_EQ(OK, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsOk());
 
   EXPECT_TRUE(req->HasAddress(kIpLiteral, 80));
 }
 
 TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) {
   proc_->AddRuleForAllFamilies("just.testing", "");
   proc_->SignalMultiple(1u);
 
   Request* req = CreateRequest("just.testing", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
   EXPECT_EQ(0u, req->NumberOfAddresses());
   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
 }
 
 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {
   proc_->AddRuleForAllFamilies(std::string(),
                                "0.0.0.0");  // Default to failures.
   proc_->SignalMultiple(1u);
 
   Request* req = CreateRequest("just.testing", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 
   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
 
   // Also test that the error is not cached.
-  EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache());
+  EXPECT_THAT(req->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS));
 }
 
 TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
   Request* req0 = CreateRequest("just.testing", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
+  EXPECT_THAT(req0->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(proc_->WaitFor(1u));
 
   // Resolver is destroyed while job is running on WorkerPool.
   resolver_.reset();
 
   proc_->SignalAll();
 
   // To ensure there was no spurious callback, complete with a new resolver.
   CreateResolver();
   Request* req1 = CreateRequest("just.testing", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req1->Resolve());
+  EXPECT_THAT(req1->Resolve(), IsError(ERR_IO_PENDING));
 
   proc_->SignalMultiple(2u);
 
-  EXPECT_EQ(OK, req1->WaitForResult());
+  EXPECT_THAT(req1->WaitForResult(), IsOk());
 
   // This request was canceled.
   EXPECT_FALSE(req0->completed());
 }
 
 #if defined(THREAD_SANITIZER)
 // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
 #define MAYBE_NumericIPv4Address DISABLED_NumericIPv4Address
 #else
 #define MAYBE_NumericIPv4Address NumericIPv4Address
 #endif
 TEST_F(HostResolverImplTest, MAYBE_NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
   Request* req = CreateRequest("127.1.2.3", 5555);
-  EXPECT_EQ(OK, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsOk());
 
   EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555));
 }
 
 #if defined(THREAD_SANITIZER)
 // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
 #define MAYBE_NumericIPv6Address DISABLED_NumericIPv6Address
 #else
 #define MAYBE_NumericIPv6Address NumericIPv6Address
 #endif
 TEST_F(HostResolverImplTest, MAYBE_NumericIPv6Address) {
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   Request* req = CreateRequest("2001:db8::1", 5555);
-  EXPECT_EQ(OK, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsOk());
 
   EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555));
 }
 
 #if defined(THREAD_SANITIZER)
 // Use of WorkerPool in HostResolverImpl causes a data race. crbug.com/334140
 #define MAYBE_EmptyHost DISABLED_EmptyHost
 #else
 #define MAYBE_EmptyHost EmptyHost
 #endif
 TEST_F(HostResolverImplTest, MAYBE_EmptyHost) {
   Request* req = CreateRequest(std::string(), 5555);
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));
 }
 
 #if defined(THREAD_SANITIZER)
 // There's a data race in this test that may lead to use-after-free.
 // If the test starts to crash without ThreadSanitizer it needs to be disabled
 // globally. See http://crbug.com/268946 (stacks for this test in
 // crbug.com/333567).
 #define MAYBE_EmptyDotsHost DISABLED_EmptyDotsHost
 #else
 #define MAYBE_EmptyDotsHost EmptyDotsHost
 #endif
 TEST_F(HostResolverImplTest, MAYBE_EmptyDotsHost) {
   for (int i = 0; i < 16; ++i) {
     Request* req = CreateRequest(std::string(i, '.'), 5555);
-    EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
+    EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));
   }
 }
 
 #if defined(THREAD_SANITIZER)
 // There's a data race in this test that may lead to use-after-free.
 // If the test starts to crash without ThreadSanitizer it needs to be disabled
 // globally. See http://crbug.com/268946.
 #define MAYBE_LongHost DISABLED_LongHost
 #else
 #define MAYBE_LongHost LongHost
 #endif
 TEST_F(HostResolverImplTest, MAYBE_LongHost) {
   Request* req = CreateRequest(std::string(4097, 'a'), 5555);
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));
 }
 
 TEST_F(HostResolverImplTest, DeDupeRequests) {
   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
+  EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 81)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("a", 82)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING));
 
   proc_->SignalMultiple(2u);  // One for "a", one for "b".
 
   for (size_t i = 0; i < requests_.size(); ++i) {
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
   }
 }
 
 TEST_F(HostResolverImplTest, CancelMultipleRequests) {
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
+  EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 81)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("a", 82)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING));
 
   // Cancel everything except request for ("a", 82).
   requests_[0]->Cancel();
   requests_[1]->Cancel();
   requests_[2]->Cancel();
   requests_[4]->Cancel();
 
   proc_->SignalMultiple(2u);  // One for "a", one for "b".
 
-  EXPECT_EQ(OK, requests_[3]->WaitForResult());
+  EXPECT_THAT(requests_[3]->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) {
   // Fill up the dispatcher and queue.
   for (unsigned i = 0; i < kMaxJobs + 1; ++i) {
     std::string hostname = "a_";
     hostname[1] = 'a' + i;
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve());
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 81)->Resolve());
+    EXPECT_THAT(CreateRequest(hostname, 80)->Resolve(),
+                IsError(ERR_IO_PENDING));
+    EXPECT_THAT(CreateRequest(hostname, 81)->Resolve(),
+                IsError(ERR_IO_PENDING));
   }
 
   EXPECT_TRUE(proc_->WaitFor(kMaxJobs));
 
   // Cancel all but last two.
   for (unsigned i = 0; i < requests_.size() - 2; ++i) {
     requests_[i]->Cancel();
   }
 
   EXPECT_TRUE(proc_->WaitFor(kMaxJobs + 1));
 
   proc_->SignalAll();
 
   size_t num_requests = requests_.size();
-  EXPECT_EQ(OK, requests_[num_requests - 1]->WaitForResult());
-  EXPECT_EQ(OK, requests_[num_requests - 2]->result());
+  EXPECT_THAT(requests_[num_requests - 1]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[num_requests - 2]->result(), IsOk());
 }
 
 TEST_F(HostResolverImplTest, CancelWithinCallback) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       // Port 80 is the first request that the callback will be invoked for.
       // While we are executing within that callback, cancel the other requests
       // in the job and start another request.
       if (req->index() == 0) {
         // Once "a:80" completes, it will cancel "a:81" and "a:82".
         requests()[1]->Cancel();
         requests()[2]->Cancel();
       }
     }
   };
   set_handler(new MyHandler());
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for "finalrequest".
 
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
 
   Request* final_request = CreateRequest("finalrequest", 70);
-  EXPECT_EQ(ERR_IO_PENDING, final_request->Resolve());
-  EXPECT_EQ(OK, final_request->WaitForResult());
+  EXPECT_THAT(final_request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(final_request->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[3]->completed());
 }
 
 TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
       DeleteResolver();
@@ skipping 26 matching lines @@
 
       // Quit after returning from OnCompleted (to give it a chance at
       // incorrectly running the cancelled tasks).
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     }
   };
   set_handler(new MyHandler());
 
   // This test assumes that the Jobs will be Aborted in order ["a", "b"]
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING));
   // HostResolverImpl will be deleted before later Requests can complete.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 81)->Resolve());
+  EXPECT_THAT(CreateRequest("a", 81)->Resolve(), IsError(ERR_IO_PENDING));
   // Job for 'b' will be aborted before it can complete.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 82)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve());
+  EXPECT_THAT(CreateRequest("b", 82)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b", 83)->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(proc_->WaitFor(1u));
 
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
 
   // |MyHandler| will send quit message once all the requests have finished.
   base::RunLoop().Run();
 
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
-  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
-  EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result());
-  EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result());
+  EXPECT_THAT(requests_[0]->result(), IsError(ERR_NETWORK_CHANGED));
+  EXPECT_THAT(requests_[1]->result(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[2]->result(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[3]->result(), IsError(ERR_IO_PENDING));
   // Clean up.
   proc_->SignalMultiple(requests_.size());
 }
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is disabled, this will result in another async request.
-        EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
+        EXPECT_THAT(CreateRequest("a", 70)->Resolve(), IsError(ERR_IO_PENDING));
       }
     }
   };
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
   HostResolver::Options options = DefaultOptions();
   options.enable_caching = false;
   resolver_.reset(new TestHostResolverImpl(options, NULL));
   resolver_->set_proc_params_for_test(DefaultParams(proc_.get()));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
 
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
   ASSERT_EQ(5u, requests_.size());
-  EXPECT_EQ(OK, requests_.back()->WaitForResult());
+  EXPECT_THAT(requests_.back()->WaitForResult(), IsOk());
 
   EXPECT_EQ(2u, proc_->GetCaptureList().size());
 }
 
 TEST_F(HostResolverImplTest, BypassCache) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is enabled, this should complete synchronously.
         std::string hostname = req->info().hostname();
-        EXPECT_EQ(OK, CreateRequest(hostname, 70)->Resolve());
-        EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache());
+        EXPECT_THAT(CreateRequest(hostname, 70)->Resolve(), IsOk());
+        EXPECT_THAT(CreateRequest(hostname, 75)->ResolveFromCache(), IsOk());
 
         // Ok good. Now make sure that if we ask to bypass the cache, it can no
         // longer service the request synchronously.
         HostResolver::RequestInfo info(HostPortPair(hostname, 71));
         info.set_allow_cached_response(false);
         EXPECT_EQ(ERR_IO_PENDING,
                   CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
       } else if (71 == req->info().port()) {
         // Test is done.
         base::MessageLoop::current()->QuitWhenIdle();
       } else {
         FAIL() << "Unexpected request";
       }
     }
   };
   set_handler(new MyHandler());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("a", 80)->Resolve(), IsError(ERR_IO_PENDING));
   proc_->SignalMultiple(3u);  // Only need two, but be generous.
 
   // |verifier| will send quit message once all the requests have finished.
   base::RunLoop().Run();
   EXPECT_EQ(2u, proc_->GetCaptureList().size());
 }
 
 // Test that IP address changes flush the cache but initial DNS config reads do
 // not.
 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
   proc_->SignalMultiple(2u);  // One before the flush, one after.
 
   Request* req = CreateRequest("host1", 70);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 
   req = CreateRequest("host1", 75);
-  EXPECT_EQ(OK, req->Resolve());  // Should complete synchronously.
+  EXPECT_THAT(req->Resolve(), IsOk());  // Should complete synchronously.
 
   // Verify initial DNS config read does not flush cache.
   NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests();
   req = CreateRequest("host1", 75);
-  EXPECT_EQ(OK, req->Resolve());  // Should complete synchronously.
+  EXPECT_THAT(req->Resolve(), IsOk());  // Should complete synchronously.
 
   // Flush cache by triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   base::RunLoop().RunUntilIdle();  // Notification happens async.
 
   // Resolve "host1" again -- this time it won't be served from cache, so it
   // will complete asynchronously.
   req = CreateRequest("host1", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 }
 
 // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests.
 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
   Request* req = CreateRequest("host1", 70);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(proc_->WaitFor(1u));
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   base::RunLoop().RunUntilIdle();  // Notification happens async.
   proc_->SignalAll();
 
-  EXPECT_EQ(ERR_NETWORK_CHANGED, req->WaitForResult());
+  EXPECT_THAT(req->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
   EXPECT_EQ(0u, resolver_->GetHostCache()->size());
 }
 
 // Test that initial DNS config read signals do not abort pending requests.
 TEST_F(HostResolverImplTest, DontAbortOnInitialDNSConfigRead) {
   Request* req = CreateRequest("host1", 70);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(proc_->WaitFor(1u));
   // Triggering initial DNS config read signal.
   NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests();
   base::RunLoop().RunUntilIdle();  // Notification happens async.
   proc_->SignalAll();
 
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 }
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
   // Runs at most one job at a time.
   CreateSerialResolver();
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a")->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b")->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("c")->Resolve());
+  EXPECT_THAT(CreateRequest("a")->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("b")->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("c")->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_TRUE(proc_->WaitFor(1u));
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   base::RunLoop().RunUntilIdle();  // Notification happens async.
   proc_->SignalMultiple(3u);  // Let the false-start go so that we can catch it.
 
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
 
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
 
   EXPECT_FALSE(requests_[1]->completed());
   EXPECT_FALSE(requests_[2]->completed());
 
-  EXPECT_EQ(OK, requests_[2]->WaitForResult());
-  EXPECT_EQ(OK, requests_[1]->result());
+  EXPECT_THAT(requests_[2]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[1]->result(), IsOk());
 }
 
 // Tests that a new Request made from the callback of a previously aborted one
 // will not be aborted.
 TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
   struct MyHandler : public Handler {
     void Handle(Request* req) override {
       // Start new request for a different hostname to ensure that the order
       // of jobs in HostResolverImpl is not stable.
       std::string hostname;
       if (req->index() == 0)
         hostname = "zzz";
       else if (req->index() == 1)
         hostname = "aaa";
       else if (req->index() == 2)
         hostname = "eee";
       else
         return;  // A request started from within MyHandler.
       EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname)->Resolve()) << hostname;
     }
   };
   set_handler(new MyHandler());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("bbb")->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("eee")->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ccc")->Resolve());
+  EXPECT_THAT(CreateRequest("bbb")->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("eee")->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("ccc")->Resolve(), IsError(ERR_IO_PENDING));
 
   // Wait until all are blocked;
   EXPECT_TRUE(proc_->WaitFor(3u));
   // Trigger an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   // This should abort all running jobs.
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->result());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->result());
+  EXPECT_THAT(requests_[0]->result(), IsError(ERR_NETWORK_CHANGED));
+  EXPECT_THAT(requests_[1]->result(), IsError(ERR_NETWORK_CHANGED));
+  EXPECT_THAT(requests_[2]->result(), IsError(ERR_NETWORK_CHANGED));
   ASSERT_EQ(6u, requests_.size());
   // Unblock all calls to proc.
   proc_->SignalMultiple(requests_.size());
   // Run until the re-started requests finish.
-  EXPECT_EQ(OK, requests_[3]->WaitForResult());
-  EXPECT_EQ(OK, requests_[4]->WaitForResult());
-  EXPECT_EQ(OK, requests_[5]->WaitForResult());
+  EXPECT_THAT(requests_[3]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[4]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[5]->WaitForResult(), IsOk());
   // Verify that results of aborted Jobs were not cached.
   EXPECT_EQ(6u, proc_->GetCaptureList().size());
   EXPECT_EQ(3u, resolver_->GetHostCache()->size());
 }
 
 // Tests that when the maximum threads is set to 1, requests are dequeued
 // in order of priority.
 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
   CreateSerialResolver();
 
@@ skipping 41 matching lines @@
   CreateSerialResolver();
 
   CreateRequest("req0", 80, MEDIUM);
   CreateRequest("req1", 80, LOW);
   CreateRequest("req2", 80, LOWEST);
 
   ASSERT_EQ(3u, requests_.size());
 
   // req0 starts immediately; without ChangePriority, req1 and then req2 should
   // run.
-  EXPECT_EQ(ERR_IO_PENDING, requests_[0]->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, requests_[2]->Resolve());
+  EXPECT_THAT(requests_[0]->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[1]->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[2]->Resolve(), IsError(ERR_IO_PENDING));
 
   // Changing req2 to HIGH should make it run before req1.
   // (It can't run before req0, since req0 started immediately.)
   requests_[2]->ChangePriority(HIGHEST);
 
   // Let all 3 requests finish.
   proc_->SignalMultiple(3u);
 
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
-  EXPECT_EQ(OK, requests_[2]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[2]->WaitForResult(), IsOk());
 
   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   ASSERT_EQ(3u, capture_list.size());
 
   EXPECT_EQ("req0", capture_list[0].hostname);
   EXPECT_EQ("req2", capture_list[1].hostname);
   EXPECT_EQ("req1", capture_list[2].hostname);
 }
 
 // Try cancelling a job which has not started yet.
@@ skipping 43 matching lines @@
 TEST_F(HostResolverImplTest, QueueOverflow) {
   CreateSerialResolver();
 
   // Allow only 3 queued jobs.
   const size_t kMaxPendingJobs = 3u;
   resolver_->SetMaxQueuedJobs(kMaxPendingJobs);
 
   // Note that at this point the MockHostResolverProc is blocked, so any
   // requests we make will not complete.
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req0", 80, LOWEST)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req1", 80, HIGHEST)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req2", 80, MEDIUM)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req3", 80, MEDIUM)->Resolve());
+  EXPECT_THAT(CreateRequest("req0", 80, LOWEST)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("req1", 80, HIGHEST)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("req2", 80, MEDIUM)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("req3", 80, MEDIUM)->Resolve(),
+              IsError(ERR_IO_PENDING));
 
   // At this point, there are 3 enqueued jobs.
   // Insertion of subsequent requests will cause evictions
   // based on priority.
 
   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE,
             CreateRequest("req4", 80, LOW)->Resolve());  // Evicts itself!
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req5", 80, MEDIUM)->Resolve());
-  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[2]->result());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req6", 80, HIGHEST)->Resolve());
-  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[3]->result());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req7", 80, MEDIUM)->Resolve());
-  EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[5]->result());
+  EXPECT_THAT(CreateRequest("req5", 80, MEDIUM)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[2]->result(),
+              IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
+  EXPECT_THAT(CreateRequest("req6", 80, HIGHEST)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[3]->result(),
+              IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
+  EXPECT_THAT(CreateRequest("req7", 80, MEDIUM)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[5]->result(),
+              IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
 
   // Unblock the resolver thread so the requests can run.
   proc_->SignalMultiple(4u);
 
   // The rest should succeed.
-  EXPECT_EQ(OK, requests_[7]->WaitForResult());
-  EXPECT_EQ(OK, requests_[0]->result());
-  EXPECT_EQ(OK, requests_[1]->result());
-  EXPECT_EQ(OK, requests_[6]->result());
+  EXPECT_THAT(requests_[7]->WaitForResult(), IsOk());
+  EXPECT_THAT(requests_[0]->result(), IsOk());
+  EXPECT_THAT(requests_[1]->result(), IsOk());
+  EXPECT_THAT(requests_[6]->result(), IsOk());
 
   // Verify that they called out the the resolver proc (which runs on the
   // resolver thread) in the expected order.
   MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
   ASSERT_EQ(4u, capture_list.size());
 
   EXPECT_EQ("req0", capture_list[0].hostname);
   EXPECT_EQ("req1", capture_list[1].hostname);
   EXPECT_EQ("req6", capture_list[2].hostname);
   EXPECT_EQ("req7", capture_list[3].hostname);
 
   // Verify that the evicted (incomplete) requests were not cached.
   EXPECT_EQ(4u, resolver_->GetHostCache()->size());
 
   for (size_t i = 0; i < requests_.size(); ++i) {
     EXPECT_TRUE(requests_[i]->completed()) << i;
   }
 }
 
 // Make sure that the address family parameter is respected when raw IPs are
 // passed in.
 TEST_F(HostResolverImplTest, AddressFamilyWithRawIPs) {
   Request* request =
       CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(OK, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsOk());
   EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80));
 
   request = CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV6);
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));
 
   request = CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
-  EXPECT_EQ(OK, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsOk());
   EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80));
 
   request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_NAME_NOT_RESOLVED));
 
   request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_IPV6);
-  EXPECT_EQ(OK, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsOk());
   EXPECT_TRUE(request->HasOneAddress("::1", 80));
 
   request = CreateRequest("::1", 80,  MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
-  EXPECT_EQ(OK, request->Resolve());
+  EXPECT_THAT(request->Resolve(), IsOk());
   EXPECT_TRUE(request->HasOneAddress("::1", 80));
 }
 
 TEST_F(HostResolverImplTest, ResolveFromCache) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);  // Need only one.
 
   HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
 
   // First hit will miss the cache.
   EXPECT_EQ(ERR_DNS_CACHE_MISS,
             CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
 
   // This time, we fetch normally.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
 
   // Now we should be able to fetch from the cache.
-  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(),
+              IsOk());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
 }
 
 TEST_F(HostResolverImplTest, ResolveStaleFromCache) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);  // Need only one.
 
   HostResolver::RequestInfo info(HostPortPair("just.testing", 80));
 
   // First hit will miss the cache.
   EXPECT_EQ(ERR_DNS_CACHE_MISS,
             CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
 
   // This time, we fetch normally.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, DEFAULT_PRIORITY)->Resolve());
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
 
   // Now we should be able to fetch from the cache.
-  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache(),
+              IsOk());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80));
-  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(),
+              IsOk());
   EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.42", 80));
   EXPECT_FALSE(requests_[3]->staleness().is_stale());
 
   MakeCacheStale();
 
   // Now we should be able to fetch from the cache only if we use
   // ResolveStaleFromCache.
   EXPECT_EQ(ERR_DNS_CACHE_MISS,
             CreateRequest(info, DEFAULT_PRIORITY)->ResolveFromCache());
-  EXPECT_EQ(OK, CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache());
+  EXPECT_THAT(CreateRequest(info, DEFAULT_PRIORITY)->ResolveStaleFromCache(),
+              IsOk());
   EXPECT_TRUE(requests_[5]->HasOneAddress("192.168.1.42", 80));
   EXPECT_TRUE(requests_[5]->staleness().is_stale());
 }
 
 // Test the retry attempts simulating host resolver proc that takes too long.
 TEST_F(HostResolverImplTest, MultipleAttempts) {
   // Total number of attempts would be 3 and we want the 3rd attempt to resolve
   // the host. First and second attempt will be forced to sleep until they get
   // word that a resolution has completed. The 3rd resolution attempt will try
   // to get done ASAP, and won't sleep..
@@ skipping 10 matching lines @@
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
   resolver_.reset(new TestHostResolverImpl(DefaultOptions(), NULL));
   resolver_->set_proc_params_for_test(params);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   Request* req = CreateRequest(info, DEFAULT_PRIORITY);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, req->WaitForResult());
 
   resolver_proc->WaitForAllAttemptsToFinish(
       base::TimeDelta::FromMilliseconds(60000));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
 }
 
 // If a host resolves to a list that includes 127.0.53.53, this is treated as
 // an error. 127.0.53.53 is a localhost address, however it has been given a
 // special significance by ICANN to help surfance name collision resulting from
 // the new gTLDs.
 TEST_F(HostResolverImplTest, NameCollision127_0_53_53) {
   proc_->AddRuleForAllFamilies("single", "127.0.53.53");
   proc_->AddRuleForAllFamilies("multiple", "127.0.0.1,127.0.53.53");
   proc_->AddRuleForAllFamilies("ipv6", "::127.0.53.53");
   proc_->AddRuleForAllFamilies("not_reserved1", "53.53.0.127");
   proc_->AddRuleForAllFamilies("not_reserved2", "127.0.53.54");
   proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53");
   proc_->SignalMultiple(6u);
 
   Request* request;
 
   request = CreateRequest("single");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(ERR_ICANN_NAME_COLLISION, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
 
   request = CreateRequest("multiple");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(ERR_ICANN_NAME_COLLISION, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
 
   // Resolving an IP literal of 127.0.53.53 however is allowed.
-  EXPECT_EQ(OK, CreateRequest("127.0.53.53")->Resolve());
+  EXPECT_THAT(CreateRequest("127.0.53.53")->Resolve(), IsOk());
 
   // Moreover the address should not be recognized when embedded in an IPv6
   // address.
   request = CreateRequest("ipv6");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(OK, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsOk());
 
   // Try some other IPs which are similar, but NOT an exact match on
   // 127.0.53.53.
   request = CreateRequest("not_reserved1");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(OK, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsOk());
 
   request = CreateRequest("not_reserved2");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(OK, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsOk());
 
   request = CreateRequest("not_reserved3");
-  EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
-  EXPECT_EQ(OK, request->WaitForResult());
+  EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(request->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplTest, IsIPv6Reachable) {
   // The real HostResolverImpl is needed since TestHostResolverImpl will
   // bypass the IPv6 reachability tests.
   resolver_.reset(new HostResolverImpl(DefaultOptions(), nullptr));
 
   // Verify that two consecutive calls return the same value.
   TestNetLog net_log;
   BoundNetLog bound_net_log = BoundNetLog::Make(&net_log, NetLog::SOURCE_NONE);
@@ skipping 108 matching lines @@
 // TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 // Test successful and fallback resolutions in HostResolverImpl::DnsTask.
 TEST_F(HostResolverImplDnsTest, DnsTask) {
   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
   // All other hostnames will fail in proc_.
 
   // Initially there is no config, so client should not be invoked.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok_fail", 80)->Resolve(), IsError(ERR_IO_PENDING));
   proc_->SignalMultiple(requests_.size());
 
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 1; i < requests_.size(); ++i)
     EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << i;
 
-  EXPECT_EQ(OK, requests_[1]->result());
+  EXPECT_THAT(requests_[1]->result(), IsOk());
   // Resolved by MockDnsClient.
   EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80));
   // Fallback to ProcTask.
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result());
-  EXPECT_EQ(OK, requests_[3]->result());
+  EXPECT_THAT(requests_[2]->result(), IsError(ERR_NAME_NOT_RESOLVED));
+  EXPECT_THAT(requests_[3]->result(), IsOk());
   EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.102", 80));
 }
 
 // Test successful and failing resolutions in HostResolverImpl::DnsTask when
 // fallback to ProcTask is disabled.
 TEST_F(HostResolverImplDnsTest, NoFallbackToProcTask) {
   set_fallback_to_proctask(false);
 
   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
   // All other hostnames will fail in proc_.
 
   // Set empty DnsConfig.
   ChangeDnsConfig(DnsConfig());
   // Initially there is no config, so client should not be invoked.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok_fail", 80)->Resolve(), IsError(ERR_IO_PENDING));
   // There is no config, so fallback to ProcTask must work.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("nx_succeed", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
   proc_->SignalMultiple(requests_.size());
 
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.1.102", 80));
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
 
   // Simulate the case when the preference or policy has disabled the DNS client
   // causing AbortDnsTasks.
   resolver_->SetDnsClient(
       std::unique_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
   ChangeDnsConfig(CreateValidDnsConfig());
 
   // First request is resolved by MockDnsClient, others should fail due to
   // disabled fallback to ProcTask.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   proc_->SignalMultiple(requests_.size());
 
   // Aborted due to Network Change.
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->WaitForResult());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[3]->WaitForResult());
+  EXPECT_THAT(requests_[2]->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
+  EXPECT_THAT(requests_[3]->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
   // Resolved by MockDnsClient.
-  EXPECT_EQ(OK, requests_[4]->WaitForResult());
+  EXPECT_THAT(requests_[4]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[4]->HasOneAddress("127.0.0.1", 80));
   // Fallback to ProcTask is disabled.
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[5]->WaitForResult());
+  EXPECT_THAT(requests_[5]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 }
 
 // Test behavior of OnDnsTaskFailure when Job is aborted.
 TEST_F(HostResolverImplDnsTest, OnDnsTaskFailureAbortedJob) {
   ChangeDnsConfig(CreateValidDnsConfig());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("nx_abort", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
   // Abort all jobs here.
   CreateResolver();
   proc_->SignalMultiple(requests_.size());
   // Run to completion.
   base::RunLoop().RunUntilIdle();  // Notification happens async.
   // It shouldn't crash during OnDnsTaskFailure callbacks.
-  EXPECT_EQ(ERR_IO_PENDING, requests_[0]->result());
+  EXPECT_THAT(requests_[0]->result(), IsError(ERR_IO_PENDING));
 
   // Repeat test with Fallback to ProcTask disabled
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("nx_abort", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
   // Abort all jobs here.
   CreateResolver();
   // Run to completion.
   base::RunLoop().RunUntilIdle();  // Notification happens async.
   // It shouldn't crash during OnDnsTaskFailure callbacks.
-  EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
+  EXPECT_THAT(requests_[1]->result(), IsError(ERR_IO_PENDING));
 }
 
 TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("4nx", "192.168.1.101");
   // All other hostnames will fail in proc_.
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4ok", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6ok", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4nx", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("4ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("6ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("4nx", 80)->Resolve(), IsError(ERR_IO_PENDING));
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 
   EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
   EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());
   EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
   EXPECT_EQ(1u, requests_[3]->NumberOfAddresses());
   EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
 }
 
 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
   DnsConfig config = CreateValidDnsConfig();
   ChangeDnsConfig(config);
 
   proc_->AddRuleForAllFamilies(std::string(),
                                std::string());  // Default to failures.
   proc_->SignalMultiple(1u);  // For the first request which misses.
 
   Request* req0 = CreateRequest("nx_ipv4", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult());
+  EXPECT_THAT(req0->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req0->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 
   IPAddress local_ipv4 = IPAddress::IPv4Localhost();
   IPAddress local_ipv6 = IPAddress::IPv6Localhost();
 
   DnsHosts hosts;
   hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   hosts[DnsHostsKey("nx_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
 
   // Update HOSTS file.
   config.hosts = hosts;
   ChangeDnsConfig(config);
 
   Request* req1 = CreateRequest("nx_ipv4", 80);
-  EXPECT_EQ(OK, req1->Resolve());
+  EXPECT_THAT(req1->Resolve(), IsOk());
   EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
 
   Request* req2 = CreateRequest("nx_ipv6", 80);
-  EXPECT_EQ(OK, req2->Resolve());
+  EXPECT_THAT(req2->Resolve(), IsOk());
   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
 
   Request* req3 = CreateRequest("nx_both", 80);
-  EXPECT_EQ(OK, req3->Resolve());
+  EXPECT_THAT(req3->Resolve(), IsOk());
   EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) &&
               req3->HasAddress("::1", 80));
 
   // Requests with specified AddressFamily.
   Request* req4 = CreateRequest("nx_ipv4", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(OK, req4->Resolve());
+  EXPECT_THAT(req4->Resolve(), IsOk());
   EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80));
 
   Request* req5 = CreateRequest("nx_ipv6", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
-  EXPECT_EQ(OK, req5->Resolve());
+  EXPECT_THAT(req5->Resolve(), IsOk());
   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
 
   // Request with upper case.
   Request* req6 = CreateRequest("nx_IPV4", 80);
-  EXPECT_EQ(OK, req6->Resolve());
+  EXPECT_THAT(req6->Resolve(), IsOk());
   EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80));
 }
 
 TEST_F(HostResolverImplDnsTest, BypassDnsTask) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies(std::string(),
                                std::string());  // Default to failures.
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok.local", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("ok.local.", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("oklocal", 80)->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("oklocal.", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < 2; ++i)
     EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i;
 
   for (size_t i = 2; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 }
 
 TEST_F(HostResolverImplDnsTest, SystemOnlyBypassesDnsTask) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies(std::string(), std::string());
 
   HostResolver::RequestInfo info_bypass(HostPortPair("ok", 80));
   info_bypass.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info_bypass, MEDIUM)->Resolve());
+  EXPECT_THAT(CreateRequest(info_bypass, MEDIUM)->Resolve(),
+              IsError(ERR_IO_PENDING));
 
   HostResolver::RequestInfo info(HostPortPair("ok", 80));
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info, MEDIUM)->Resolve());
+  EXPECT_THAT(CreateRequest(info, MEDIUM)->Resolve(), IsError(ERR_IO_PENDING));
 
   proc_->SignalMultiple(requests_.size());
 
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies(std::string(),
                                std::string());  // Default to failures.
 
   // Check that DnsTask works.
   Request* req = CreateRequest("ok_1", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 
   for (unsigned i = 0; i < maximum_dns_failures(); ++i) {
     // Use custom names to require separate Jobs.
     std::string hostname = base::StringPrintf("nx_%u", i);
     // Ensure fallback to ProcTask succeeds.
     proc_->AddRuleForAllFamilies(hostname, "192.168.1.101");
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 
   ASSERT_FALSE(proc_->HasBlockedRequests());
 
   // DnsTask should be disabled by now.
   req = CreateRequest("ok_2", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
   proc_->SignalMultiple(1u);
-  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult());
+  EXPECT_THAT(req->WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
 
   // Check that it is re-enabled after DNS change.
   ChangeDnsConfig(CreateValidDnsConfig());
   req = CreateRequest("ok_3", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 }
 
 TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   // |proc_| defaults to successes.
 
   // 20 failures interleaved with 20 successes.
   for (unsigned i = 0; i < 40; ++i) {
     // Use custom names to require separate Jobs.
     std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i)
                                         : base::StringPrintf("ok_%u", i);
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < requests_.size(); ++i)
     EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
 
   // Make |proc_| default to failures.
   proc_->AddRuleForAllFamilies(std::string(), std::string());
 
   // DnsTask should still be enabled.
   Request* req = CreateRequest("ok_last", 80);
-  EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
-  EXPECT_EQ(OK, req->WaitForResult());
+  EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(req->WaitForResult(), IsOk());
 }
 
 // Confirm that resolving "localhost" is unrestricted even if there are no
 // global IPv6 address. See SystemHostResolverCall for rationale.
 // Test both the DnsClient and system host resolver paths.
 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   // Use regular SystemHostResolverCall!
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
   resolver_.reset(new TestHostResolverImpl(DefaultOptions(), NULL, false));
   resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
@@ skipping 18 matching lines @@
 
   // Try without DnsClient.
   DnsConfig config = CreateValidDnsConfig();
   config.use_local_ipv6 = false;
   ChangeDnsConfig(config);
   HostResolver::RequestInfo info_proc(HostPortPair("localhost", 80));
   info_proc.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
   info_proc.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
   Request* req = CreateRequest(info_proc, DEFAULT_PRIORITY);
 
-  EXPECT_EQ(OK, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsOk());
 
   EXPECT_TRUE(req->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(req->HasAddress("::1", 80));
 
   // Configure DnsClient with dual-host HOSTS file.
   DnsConfig config_hosts = CreateValidDnsConfig();
   DnsHosts hosts;
   IPAddress local_ipv4 = IPAddress::IPv4Localhost();
   IPAddress local_ipv6 = IPAddress::IPv6Localhost();
   if (saw_ipv4)
     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   if (saw_ipv6)
     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   config_hosts.hosts = hosts;
 
   ChangeDnsConfig(config_hosts);
   HostResolver::RequestInfo info_hosts(HostPortPair("localhost", 80));
   info_hosts.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
   req = CreateRequest(info_hosts, DEFAULT_PRIORITY);
   // Expect synchronous resolution from DnsHosts.
-  EXPECT_EQ(OK, req->Resolve());
+  EXPECT_THAT(req->Resolve(), IsOk());
 
   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
 }
 
 // Cancel a request with a single DNS transaction active.
 TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActive) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING,
             CreateRequest("ok", 80, MEDIUM, ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with a single DNS transaction active and another pending.
 TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActiveOnePending) {
   CreateSerialResolver();
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with two DNS transactions active.
 TEST_F(HostResolverImplDnsTest, CancelWithTwoTransactionsActive) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Delete a resolver with some active requests and some queued requests.
 TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
   // At most 10 Jobs active at once.
   CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()));
@@ skipping 13 matching lines @@
   }
   EXPECT_EQ(10u, num_running_dispatcher_jobs());
 
   resolver_.reset();
 }
 
 // Cancel a request with only the IPv6 transaction active.
 TEST_F(HostResolverImplDnsTest, CancelWithIPv6TransactionActive) {
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6slow_ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("6slow_ok", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // The IPv4 request should complete, the IPv6 request is still pending.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with only the IPv4 transaction pending.
 TEST_F(HostResolverImplDnsTest, CancelWithIPv4TransactionPending) {
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("4slow_ok", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // The IPv6 request should complete, the IPv4 request is still pending.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
 
   requests_[0]->Cancel();
 }
 
 // Test cases where AAAA completes first.
 TEST_F(HostResolverImplDnsTest, AAAACompletesFirst) {
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4ok", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4timeout", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_6timeout", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("4slow_ok", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("4slow_4ok", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("4slow_4timeout", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("4slow_6timeout", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(requests_[0]->completed());
   EXPECT_FALSE(requests_[1]->completed());
   EXPECT_FALSE(requests_[2]->completed());
   // The IPv6 of the third request should have failed and resulted in cancelling
   // the IPv4 request.
   EXPECT_TRUE(requests_[3]->completed());
-  EXPECT_EQ(ERR_DNS_TIMED_OUT, requests_[3]->result());
+  EXPECT_THAT(requests_[3]->result(), IsError(ERR_DNS_TIMED_OUT));
   EXPECT_EQ(3u, num_running_dispatcher_jobs());
 
   dns_client_->CompleteDelayedTransactions();
   EXPECT_TRUE(requests_[0]->completed());
-  EXPECT_EQ(OK, requests_[0]->result());
+  EXPECT_THAT(requests_[0]->result(), IsOk());
   EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
 
   EXPECT_TRUE(requests_[1]->completed());
-  EXPECT_EQ(OK, requests_[1]->result());
+  EXPECT_THAT(requests_[1]->result(), IsOk());
   EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
 
   EXPECT_TRUE(requests_[2]->completed());
-  EXPECT_EQ(ERR_DNS_TIMED_OUT, requests_[2]->result());
+  EXPECT_THAT(requests_[2]->result(), IsError(ERR_DNS_TIMED_OUT));
 }
 
 // Test the case where only a single transaction slot is available.
 TEST_F(HostResolverImplDnsTest, SerialResolver) {
   CreateSerialResolver();
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_THAT(CreateRequest("ok", 80)->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(requests_[0]->completed());
-  EXPECT_EQ(OK, requests_[0]->result());
+  EXPECT_THAT(requests_[0]->result(), IsOk());
   EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
 }
 
 // Test the case where the AAAA query is started when another transaction
 // completes.
 TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
   CreateResolverWithLimitsAndParams(2u, DefaultParams(proc_.get()));
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING,
             CreateRequest("4slow_ok", 80, MEDIUM)->Resolve());
   // An IPv4 request should have been started pending for each job.
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // Request 0's IPv4 request should complete, starting Request 1's IPv6
   // request, which should also complete.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   EXPECT_TRUE(requests_[0]->completed());
   EXPECT_FALSE(requests_[1]->completed());
 
   dns_client_->CompleteDelayedTransactions();
   EXPECT_TRUE(requests_[1]->completed());
-  EXPECT_EQ(OK, requests_[1]->result());
+  EXPECT_THAT(requests_[1]->result(), IsOk());
   EXPECT_EQ(2u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[1]->HasAddress("::1", 80));
 }
 
 // Tests the case that a Job with a single transaction receives an empty address
 // list, triggering fallback to ProcTask.
 TEST_F(HostResolverImplDnsTest, IPv4EmptyFallback) {
   ChangeDnsConfig(CreateValidDnsConfig());
   proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
   proc_->SignalMultiple(1u);
   EXPECT_EQ(ERR_IO_PENDING,
             CreateRequest("empty_fallback", 80, MEDIUM,
                           ADDRESS_FAMILY_IPV4)->Resolve());
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
 }
 
 // Tests the case that a Job with two transactions receives two empty address
 // lists, triggering fallback to ProcTask.
 TEST_F(HostResolverImplDnsTest, UnspecEmptyFallback) {
   ChangeDnsConfig(CreateValidDnsConfig());
   proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
   proc_->SignalMultiple(1u);
   EXPECT_EQ(ERR_IO_PENDING,
             CreateRequest("empty_fallback", 80, MEDIUM,
                           ADDRESS_FAMILY_UNSPECIFIED)->Resolve());
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
 }
 
 // Tests getting a new invalid DnsConfig while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
   CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("slow_nx1", "192.168.0.1");
   proc_->AddRuleForAllFamilies("slow_nx2", "192.168.0.2");
   proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
 
   // First active job gets two slots.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx1")->Resolve());
+  EXPECT_THAT(CreateRequest("slow_nx1")->Resolve(), IsError(ERR_IO_PENDING));
   // Next job gets one slot, and waits on another.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx2")->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok")->Resolve());
+  EXPECT_THAT(CreateRequest("slow_nx2")->Resolve(), IsError(ERR_IO_PENDING));
+  EXPECT_THAT(CreateRequest("ok")->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_EQ(3u, num_running_dispatcher_jobs());
 
   // Clear DNS config.  Two in-progress jobs should be aborted, and the next one
   // should use a ProcTask.
   ChangeDnsConfig(DnsConfig());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsError(ERR_NETWORK_CHANGED));
 
   // Finish up the third job.  Should bypass the DnsClient, and get its results
   // from MockHostResolverProc.
   EXPECT_FALSE(requests_[2]->completed());
   proc_->SignalMultiple(1u);
-  EXPECT_EQ(OK, requests_[2]->WaitForResult());
+  EXPECT_THAT(requests_[2]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 // Tests the case that DnsClient is automatically disabled due to failures
 // while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest,
        AutomaticallyDisableDnsClientWithPendingRequests) {
   // Trying different limits is important for this test:  Different limits
   // result in different behavior when aborting in-progress DnsTasks.  Having
   // a DnsTask that has one job active and one in the queue when another job
   // occupying two slots has its DnsTask aborted is the case most likely to run
   // into problems.
   for (size_t limit = 1u; limit < 6u; ++limit) {
     CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()));
 
     ChangeDnsConfig(CreateValidDnsConfig());
 
     // Queue up enough failures to disable DnsTasks.  These will all fall back
     // to ProcTasks, and succeed there.
     for (unsigned i = 0u; i < maximum_dns_failures(); ++i) {
       std::string host = base::StringPrintf("nx%u", i);
       proc_->AddRuleForAllFamilies(host, "192.168.0.1");
-      EXPECT_EQ(ERR_IO_PENDING, CreateRequest(host)->Resolve());
+      EXPECT_THAT(CreateRequest(host)->Resolve(), IsError(ERR_IO_PENDING));
     }
 
     // These requests should all bypass DnsTasks, due to the above failures,
     // so should end up using ProcTasks.
     proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.2");
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok1")->Resolve());
+    EXPECT_THAT(CreateRequest("slow_ok1")->Resolve(), IsError(ERR_IO_PENDING));
     proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.3");
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok2")->Resolve());
+    EXPECT_THAT(CreateRequest("slow_ok2")->Resolve(), IsError(ERR_IO_PENDING));
     proc_->AddRuleForAllFamilies("slow_ok3", "192.168.0.4");
-    EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok3")->Resolve());
+    EXPECT_THAT(CreateRequest("slow_ok3")->Resolve(), IsError(ERR_IO_PENDING));
     proc_->SignalMultiple(maximum_dns_failures() + 3);
 
     for (size_t i = 0u; i < maximum_dns_failures(); ++i) {
-      EXPECT_EQ(OK, requests_[i]->WaitForResult());
+      EXPECT_THAT(requests_[i]->WaitForResult(), IsOk());
       EXPECT_TRUE(requests_[i]->HasOneAddress("192.168.0.1", 80));
     }
 
-    EXPECT_EQ(OK, requests_[maximum_dns_failures()]->WaitForResult());
+    EXPECT_THAT(requests_[maximum_dns_failures()]->WaitForResult(), IsOk());
     EXPECT_TRUE(requests_[maximum_dns_failures()]->HasOneAddress(
                     "192.168.0.2", 80));
-    EXPECT_EQ(OK, requests_[maximum_dns_failures() + 1]->WaitForResult());
+    EXPECT_THAT(requests_[maximum_dns_failures() + 1]->WaitForResult(), IsOk());
     EXPECT_TRUE(requests_[maximum_dns_failures() + 1]->HasOneAddress(
                     "192.168.0.3", 80));
-    EXPECT_EQ(OK, requests_[maximum_dns_failures() + 2]->WaitForResult());
+    EXPECT_THAT(requests_[maximum_dns_failures() + 2]->WaitForResult(), IsOk());
     EXPECT_TRUE(requests_[maximum_dns_failures() + 2]->HasOneAddress(
                     "192.168.0.4", 80));
     requests_.clear();
   }
 }
 
 // Tests a call to SetDnsClient while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
   CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.1");
   proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.2");
   proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
 
   // First active job gets two slots.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok1")->Resolve());
+  EXPECT_THAT(CreateRequest("slow_ok1")->Resolve(), IsError(ERR_IO_PENDING));
   // Next job gets one slot, and waits on another.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok2")->Resolve());
+  EXPECT_THAT(CreateRequest("slow_ok2")->Resolve(), IsError(ERR_IO_PENDING));
   // Next one is queued.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok")->Resolve());
+  EXPECT_THAT(CreateRequest("ok")->Resolve(), IsError(ERR_IO_PENDING));
 
   EXPECT_EQ(3u, num_running_dispatcher_jobs());
 
   // Clear DnsClient.  The two in-progress jobs should fall back to a ProcTask,
   // and the next one should be started with a ProcTask.
   resolver_->SetDnsClient(std::unique_ptr<DnsClient>());
 
   // All three in-progress requests should now be running a ProcTask.
   EXPECT_EQ(3u, num_running_dispatcher_jobs());
   proc_->SignalMultiple(3u);
 
-  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
-  EXPECT_EQ(OK, requests_[1]->WaitForResult());
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
-  EXPECT_EQ(OK, requests_[2]->WaitForResult());
+  EXPECT_THAT(requests_[2]->WaitForResult(), IsOk());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 TEST_F(HostResolverImplTest, ResolveLocalHostname) {
   AddressList addresses;
 
   TestBothLoopbackIPs("localhost");
   TestBothLoopbackIPs("localhoST");
   TestBothLoopbackIPs("localhost.");
   TestBothLoopbackIPs("localhoST.");
@@ skipping 42 matching lines @@
   EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
   EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(
       ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
 }
 
 }  // namespace net