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

net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc

 // Copyright (c) 2013 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/proxy/proxy_resolver_v8_tracing_wrapper.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 11 matching lines @@
 #include "net/base/test_completion_callback.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/test/event_waiter.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 class ProxyResolverV8TracingWrapperTest : public testing::Test {
  public:
   void TearDown() override {
     // Drain any pending messages, which may be left over from cancellation.
     // This way they get reliably run as part of the current test, rather than
     // spilling into the next test's execution.
@@ skipping 31 matching lines @@
     std::unique_ptr<ProxyResolverErrorObserver> error_observer,
     const char* filename) {
   std::unique_ptr<ProxyResolver> resolver;
   ProxyResolverFactoryV8TracingWrapper factory(
       host_resolver, net_log,
       base::Bind(&ReturnErrorObserver, base::Passed(&error_observer)));
   TestCompletionCallback callback;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   int rv = factory.CreateProxyResolver(LoadScriptData(filename), &resolver,
                                        callback.callback(), &request);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(resolver);
   return resolver;
 }
 
 class MockErrorObserver : public ProxyResolverErrorObserver {
  public:
   void OnPACScriptError(int line_number, const base::string16& error) override {
     output += base::StringPrintf("Error: line %d: %s\n", line_number,
                                  base::UTF16ToASCII(error).c_str());
     waiter_.NotifyEvent(EVENT_ERROR);
@@ skipping 29 matching lines @@
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, base::WrapUnique(error_observer), "simple.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("foo:99", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   // There were no errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
   EXPECT_EQ(0u, request_log.GetSize());
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest, JavascriptError) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, base::WrapUnique(error_observer), "error.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PAC_SCRIPT_FAILED));
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   EXPECT_EQ(
       "Error: line 5: Uncaught TypeError: Cannot read property 'split' "
       "of null\n",
       error_observer->GetOutput());
 
   // Check the NetLogs -- there was 1 alert and 1 javascript error, and they
   // were output to both the global log, and per-request log.
@@ skipping 27 matching lines @@
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "too_many_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Iteration1 does a DNS resolve
   // Iteration2 exceeds the alert buffer
   // Iteration3 runs in blocking mode and completes
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
@@ skipping 26 matching lines @@
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "too_many_empty_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- the script generated 50 alerts, which were mirrored
   // to both the global and per-request logs.
@@ skipping 35 matching lines @@
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // The test does 13 DNS resolution, however only 7 of them are unique.
   EXPECT_EQ(7u, host_resolver.num_resolve());
 
   const char* kExpectedResult =
       "122.133.144.155-"  // myIpAddress()
       "null-"             // dnsResolve('')
       "__1_192.168.1.1-"  // dnsResolveEx('host1')
       "null-"             // dnsResolve('host2')
       "166.155.144.33-"   // dnsResolve('host3')
@@ skipping 43 matching lines @@
       &log, &host_resolver, base::WrapUnique(error_observer), "simple_dns.js");
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
                                callback1.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback1.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback1.WaitForResult(), IsOk());
 
   // The test does 2 DNS resolutions.
   EXPECT_EQ(2u, host_resolver.num_resolve());
 
   // The first request took 2 restarts, hence on g_iteration=3.
   EXPECT_EQ("166.155.144.11:3", proxy_info.proxy_server().ToURI());
 
   rv =
       resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
                                callback2.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback2.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback2.WaitForResult(), IsOk());
 
   EXPECT_EQ(4u, host_resolver.num_resolve());
 
   // This time no restarts were required, so g_iteration incremented by 1.
   EXPECT_EQ("166.155.144.11:4", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   EXPECT_EQ(0u, log.GetSize());
@@ skipping 16 matching lines @@
   std::unique_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "global_sideffects1.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // The script itself only does 2 DNS resolves per execution, however it
   // constructs the hostname using a global counter which changes on each
   // invocation.
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.11-133.199.111.4:100",
             proxy_info.proxy_server().ToURI());
 
   // No errors.
@@ skipping 32 matching lines @@
   std::unique_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "global_sideffects2.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.44:100", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- nothing was logged.
   EXPECT_EQ(0u, log.GetSize());
@@ skipping 16 matching lines @@
   std::unique_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "global_sideffects3.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(20u, host_resolver.num_resolve());
 
   EXPECT_EQ(
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
       "null:21",
@@ skipping 23 matching lines @@
   std::unique_ptr<ProxyResolver> resolver =
       CreateResolver(&log, &host_resolver, base::WrapUnique(error_observer),
                      "global_sideffects4.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(20u, host_resolver.num_resolve());
 
   EXPECT_EQ("null21:34", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   // Check the NetLogs -- 1 alert was logged.
   EXPECT_EQ(1u, log.GetSize());
@@ skipping 22 matching lines @@
 
   host_resolver.rules()->AddRule("host1", "145.88.13.3");
   host_resolver.rules()->AddRule("host2", "137.89.8.45");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Fetched host1 and host2 again, since the ones done during initialization
   // should not have been cached.
   EXPECT_EQ(4u, host_resolver.num_resolve());
 
   EXPECT_EQ("91.13.12.1-91.13.12.2-145.88.13.3-137.89.8.45:99",
             proxy_info.proxy_server().ToURI());
 
   // Check the NetLogs -- the script generated 2 alerts during initialization.
   EXPECT_EQ(0u, request_log.GetSize());
@@ skipping 37 matching lines @@
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
                                       base::Bind(&CrashCallback), &request[i],
                                       BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     resolver->CancelRequest(request[i]);
   }
 }
 
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
                                     BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info2,
                                 callback.callback(), &request2, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   resolver->CancelRequest(request1);
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Cancel a request after it has finished running on the worker thread, and has
 // posted a task the completion task back to origin thread.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://throw-an-error/"),
                                     &proxy_info1, base::Bind(&CrashCallback),
                                     &request1, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait until the first request has finished running on the worker thread.
   // Cancel the first request, while it has a pending completion task on
   // the origin thread.
   error_observer->RunOnError(base::Bind(&ProxyResolver::CancelRequest,
                                         base::Unretained(resolver.get()),
                                         request1));
 
   // Start another request, to make sure it is able to complete.
   rv = resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
                                 &proxy_info2, callback.callback(), &request2,
                                 BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("i-approve-this-message:42", proxy_info2.proxy_server().ToURI());
 }
 
 // This implementation of HostResolver allows blocking until a resolve request
 // has been received. The resolve requests it receives will never be completed.
 class BlockableHostResolver : public HostResolver {
  public:
   BlockableHostResolver()
       : num_cancelled_requests_(0), waiting_for_resolve_(false) {}
@@ skipping 66 matching lines @@
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
   ProxyResolver::RequestHandle request1;
   ProxyResolver::RequestHandle request2;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
                                     BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   rv = resolver->GetProxyForURL(GURL("http://foo/req2"), &proxy_info2,
                                 base::Bind(&CrashCallback), &request2,
                                 BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   resolver->CancelRequest(request1);
   resolver->CancelRequest(request2);
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
   // After leaving this scope, the ProxyResolver is destroyed.
   // This should not cause any problems, as the outstanding work
@@ skipping 20 matching lines @@
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
                                     BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.SetAction(
       base::Bind(CancelRequestAndPause, resolver.get(), request));
 
   host_resolver.WaitUntilRequestIsReceived();
 }
 
 // Cancel the request while there is a pending DNS request, however before
 // the request is sent to the host resolver.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, base::WrapUnique(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
   ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
                                     BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait a bit, so the DNS task has hopefully been posted. The test will
   // work whatever the delay is here, but it is most useful if the delay
   // is large enough to allow a task to be posted back.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
   resolver->CancelRequest(request);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest,
        CancelCreateResolverWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   ProxyResolverFactoryV8TracingWrapper factory(
       &host_resolver, nullptr,
       base::Bind(&ReturnErrorObserver,
                  base::Passed(base::WrapUnique(error_observer))));
 
   std::unique_ptr<ProxyResolver> resolver;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   int rv = factory.CreateProxyResolver(LoadScriptData("dns_during_init.js"),
                                        &resolver, base::Bind(&CrashCallback),
                                        &request);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   host_resolver.WaitUntilRequestIsReceived();
 
   request.reset();
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest,
        DeleteFactoryWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   std::unique_ptr<ProxyResolver> resolver;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   {
     ProxyResolverFactoryV8TracingWrapper factory(
         &host_resolver, nullptr,
         base::Bind(&ReturnErrorObserver,
                    base::Passed(base::WrapUnique(error_observer))));
 
     int rv = factory.CreateProxyResolver(LoadScriptData("dns_during_init.js"),
                                          &resolver, base::Bind(&CrashCallback),
                                          &request);
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     host_resolver.WaitUntilRequestIsReceived();
   }
   EXPECT_EQ(1, host_resolver.num_cancelled_requests());
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest, ErrorLoadingScript) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   ProxyResolverFactoryV8TracingWrapper factory(
       &host_resolver, nullptr,
       base::Bind(&ReturnErrorObserver,
                  base::Passed(base::WrapUnique(error_observer))));
 
   std::unique_ptr<ProxyResolver> resolver;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   TestCompletionCallback callback;
   int rv =
       factory.CreateProxyResolver(LoadScriptData("error_on_load.js"), &resolver,
                                   callback.callback(), &request);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PAC_SCRIPT_FAILED));
   EXPECT_FALSE(resolver);
 }
 
 // This tests that the execution of a PAC script is terminated when the DNS
 // dependencies are missing. If the test fails, then it will hang.
 TEST_F(ProxyResolverV8TracingWrapperTest, Terminate) {
   TestNetLog log;
   BoundTestNetLog request_log;
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddRule("host1", "182.111.0.222");
   host_resolver.rules()->AddRule("host2", "111.33.44.55");
 
   std::unique_ptr<ProxyResolver> resolver = CreateResolver(
       &log, &host_resolver, base::WrapUnique(error_observer), "terminate.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
   int rv =
       resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
                                callback.callback(), NULL, request_log.bound());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // The test does 2 DNS resolutions.
   EXPECT_EQ(2u, host_resolver.num_resolve());
 
   EXPECT_EQ("foopy:3", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_EQ("", error_observer->GetOutput());
 
   EXPECT_EQ(0u, log.GetSize());
@@ skipping 60 matching lines @@
   const size_t kNumIterations = 20;
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     int rv = resolver[resolver_i]->GetProxyForURL(
         GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
         BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   }
 
   // ------------------------
   // Verify all of the results.
   // ------------------------
 
   const char* kExpectedForDnsJs =
       "122.133.144.155-"  // myIpAddress()
       "null-"             // dnsResolve('')
       "__1_192.168.1.1-"  // dnsResolveEx('host1')
       "null-"             // dnsResolve('host2')
       "166.155.144.33-"   // dnsResolve('host3')
       "122.133.144.155-"  // myIpAddress()
       "166.155.144.33-"   // dnsResolve('host3')
       "__1_192.168.1.1-"  // dnsResolveEx('host1')
       "122.133.144.155-"  // myIpAddress()
       "null-"             // dnsResolve('host2')
       "-"                 // dnsResolveEx('host6')
       "133.122.100.200-"  // myIpAddressEx()
       "166.155.144.44"    // dnsResolve('host1')
       ":99";
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
-    EXPECT_EQ(OK, callback[i].WaitForResult());
+    EXPECT_THAT(callback[i].WaitForResult(), IsOk());
 
     std::string proxy_uri = proxy_info[i].proxy_server().ToURI();
 
     if (resolver_i == 0 || resolver_i == 1) {
       EXPECT_EQ(kExpectedForDnsJs, proxy_uri);
     } else if (resolver_i == 2) {
       EXPECT_EQ("foo:99", proxy_uri);
     } else if (resolver_i == 3) {
       EXPECT_EQ("166.155.144.33:",
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net