Reland "Change ProxyResolver::GetProxyForURL() to take a unique_ptr<Request>* "

net/proxy/proxy_resolver_v8_tracing_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.h"
 
 #include <string>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 147 matching lines @@
 
 TEST_F(ProxyResolverV8TracingTest, Simple) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "simple.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
+  std::unique_ptr<ProxyResolver::Request> req;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("foo:99", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   // There were no alerts or errors.
   EXPECT_TRUE(mock_bindings.GetAlerts().empty());
   EXPECT_TRUE(mock_bindings.GetErrors().empty());
 }
 
 TEST_F(ProxyResolverV8TracingTest, JavascriptError) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "error.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PAC_SCRIPT_FAILED));
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 
   // Check the output -- there was 1 alert and 1 javascript error.
   ASSERT_EQ(1u, mock_bindings.GetAlerts().size());
   EXPECT_EQ("Prepare to DIE!", mock_bindings.GetAlerts()[0]);
   ASSERT_EQ(1u, mock_bindings.GetErrors().size());
   EXPECT_EQ(5, mock_bindings.GetErrors()[0].first);
   EXPECT_EQ("Uncaught TypeError: Cannot read property 'split' of null",
             mock_bindings.GetErrors()[0].second);
 }
 
 TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "too_many_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
 
   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());
@@ skipping 14 matching lines @@
 TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver = CreateResolver(
       mock_bindings.CreateBindings(), "too_many_empty_alerts.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(1u, host_resolver.num_resolve());
 
   // No errors.
   EXPECT_TRUE(mock_bindings.GetErrors().empty());
@@ skipping 24 matching lines @@
   host_resolver.rules()->AddRuleForAddressFamily(
       "*", ADDRESS_FAMILY_IPV4, "122.133.144.155");
   host_resolver.rules()->AddRule("*", "133.122.100.200");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
 
   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('')
@@ skipping 30 matching lines @@
   host_resolver.rules()->AddRule("foopy", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "simple_dns.js");
 
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                           callback1.callback(), NULL,
+                           callback1.callback(), &req,
                            mock_bindings.CreateBindings());
 
   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());
 
+  std::unique_ptr<ProxyResolver::Request> req2;
   resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
-                           callback2.callback(), NULL,
+                           callback2.callback(), &req2,
                            mock_bindings.CreateBindings());
 
   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());
 
   // There were no alerts or errors.
@@ skipping 11 matching lines @@
   host_resolver.rules()->AddRule("host1", "166.155.144.11");
   host_resolver.rules()->AddRule("crazy4", "133.199.111.4");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "global_sideffects1.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   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());
@@ skipping 17 matching lines @@
   host_resolver.rules()->AddRule("host3", "166.155.144.33");
   host_resolver.rules()->AddRule("host4", "166.155.144.44");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "global_sideffects2.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(3u, host_resolver.num_resolve());
 
   EXPECT_EQ("166.155.144.44:100", proxy_info.proxy_server().ToURI());
 
   // There were no alerts or errors.
   EXPECT_TRUE(mock_bindings.GetAlerts().empty());
   EXPECT_TRUE(mock_bindings.GetErrors().empty());
 }
 
 // This test runs a weird PAC script that yields a never ending sequence
 // of DNS resolves when restarting. Running it will hit the maximum
 // DNS resolves per request limit (20) after which every DNS resolve will
 // fail.
 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "global_sideffects3.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   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-"
@@ skipping 18 matching lines @@
 
   host_resolver.rules()->AddRule("host*", "166.155.144.11");
   host_resolver.rules()->AddRule("*", "122.133.144.155");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "global_sideffects4.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(20u, host_resolver.num_resolve());
 
   EXPECT_EQ("null21:34", proxy_info.proxy_server().ToURI());
 
   // No errors.
   EXPECT_TRUE(mock_bindings.GetErrors().empty());
 
@@ skipping 18 matching lines @@
 
   host_resolver.rules()->ClearRules();
   host_resolver.GetHostCache()->clear();
 
   host_resolver.rules()->AddRule("host1", "145.88.13.3");
   host_resolver.rules()->AddRule("host2", "137.89.8.45");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   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());
 
@@ skipping 24 matching lines @@
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
-  ProxyResolver::RequestHandle request[kNumRequests];
+  std::unique_ptr<ProxyResolver::Request> request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
                              base::Bind(&CrashCallback), &request[i],
                              mock_bindings.CreateBindings());
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    resolver->CancelRequest(request[i]);
+    request[i].reset();
   }
 }
 
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  std::unique_ptr<ProxyResolver::Request> request1;
+  std::unique_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
                            base::Bind(&CrashCallback), &request1,
                            mock_bindings.CreateBindings());
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info2,
                            callback.callback(), &request2,
                            mock_bindings.CreateBindings());
 
-  resolver->CancelRequest(request1);
+  request1.reset();
 
   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(ProxyResolverV8TracingTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  std::unique_ptr<ProxyResolver::Request> request1;
+  std::unique_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback;
 
   resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info1,
                            base::Bind(&CrashCallback), &request1,
                            mock_bindings.CreateBindings());
 
   // Wait until the first request has finished running on the worker thread.
   // Cancel the first request, while it is running its completion task on
-  // the origin thread.
-  mock_bindings.RunOnError(base::Bind(&ProxyResolverV8Tracing::CancelRequest,
-                                      base::Unretained(resolver.get()),
-                                      request1));
+  // the origin thread. Reset deletes Request opject which cancels the request.
+  mock_bindings.RunOnError(
+      base::Bind(&std::unique_ptr<ProxyResolver::Request>::reset,
+                 base::Unretained(&request1), nullptr));
 
   // Start another request, to make sure it is able to complete.
   resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
                            &proxy_info2, callback.callback(), &request2,
                            mock_bindings.CreateBindings());
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ("i-approve-this-message:42", proxy_info2.proxy_server().ToURI());
 }
@@ skipping 83 matching lines @@
 // when the request has an outstanding DNS request in flight.
 TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  std::unique_ptr<ProxyResolver::Request> request1;
+  std::unique_ptr<ProxyResolver::Request> request2;
 
   resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                            base::Bind(&CrashCallback), &request1,
                            mock_bindings.CreateBindings());
 
   host_resolver.WaitUntilRequestIsReceived();
 
   resolver->GetProxyForURL(GURL("http://foo/req2"), &proxy_info2,
                            base::Bind(&CrashCallback), &request2,
                            mock_bindings.CreateBindings());
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  resolver->CancelRequest(request1);
-  resolver->CancelRequest(request2);
+  request1.reset();
+  request2.reset();
 
   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
   // should have been cancelled.
 }
 
-void CancelRequestAndPause(ProxyResolverV8Tracing* resolver,
-                           ProxyResolver::RequestHandle request) {
-  resolver->CancelRequest(request);
+void CancelRequestAndPause(std::unique_ptr<ProxyResolver::Request>* request) {
+  request->reset();
 
   // Sleep for a little bit. This makes it more likely for the worker
   // thread to have returned from its call, and serves as a regression
   // test for http://crbug.com/173373.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
 }
 
 // In non-blocking mode, the worker thread actually does block for
 // a short time to see if the result is in the DNS cache. Test
 // cancellation while the worker thread is waiting on this event.
 TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info;
-  ProxyResolver::RequestHandle request;
+  std::unique_ptr<ProxyResolver::Request> request;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                            base::Bind(&CrashCallback), &request,
                            mock_bindings.CreateBindings());
 
-  host_resolver.SetAction(
-      base::Bind(CancelRequestAndPause, resolver.get(), request));
+  host_resolver.SetAction(base::Bind(CancelRequestAndPause, &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(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info;
-  ProxyResolver::RequestHandle request;
+  std::unique_ptr<ProxyResolver::Request> request;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                            base::Bind(&CrashCallback), &request,
                            mock_bindings.CreateBindings());
 
   // 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);
+  request.reset();
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
 
 TEST_F(ProxyResolverV8TracingTest,
        CancelCreateResolverWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockBindings mock_bindings(&host_resolver);
 
   std::unique_ptr<ProxyResolverV8TracingFactory> factory(
@@ skipping 53 matching lines @@
 
   host_resolver.rules()->AddRule("host1", "182.111.0.222");
   host_resolver.rules()->AddRule("host2", "111.33.44.55");
 
   std::unique_ptr<ProxyResolverV8Tracing> resolver =
       CreateResolver(mock_bindings.CreateBindings(), "terminate.js");
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
+  std::unique_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                           callback.callback(), NULL,
+                           callback.callback(), &req,
                            mock_bindings.CreateBindings());
   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 or alerts.
   EXPECT_TRUE(mock_bindings.GetErrors().empty());
@@ skipping 51 matching lines @@
 
   ProxyResolverV8Tracing* resolver[] = {
       resolver0.get(), resolver1.get(), resolver2.get(), resolver3.get(),
   };
 
   const size_t kNumResolvers = arraysize(resolver);
   const size_t kNumIterations = 20;
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
+  std::unique_ptr<ProxyResolver::Request> request[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     resolver[resolver_i]->GetProxyForURL(
-        GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
-        resolver_i == 3 ? mock_bindings3.CreateBindings()
-                        : mock_bindings0.CreateBindings());
+        GURL("http://foo/"), &proxy_info[i], callback[i].callback(),
+        &request[i], resolver_i == 3 ? mock_bindings3.CreateBindings()
+                                     : mock_bindings0.CreateBindings());
   }
 
   // ------------------------
   // Verify all of the results.
   // ------------------------
 
   const char* kExpectedForDnsJs =
     "122.133.144.155-"  // myIpAddress()
     "null-"  // dnsResolve('')
     "__1_192.168.1.1-"  // dnsResolveEx('host1')
@@ skipping 24 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net