| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/proxy/proxy_resolver_v8_tracing.h" | |
| 6 | |
| 7 #include "base/files/file_util.h" | |
| 8 #include "base/message_loop/message_loop.h" | |
| 9 #include "base/path_service.h" | |
| 10 #include "base/stl_util.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/strings/stringprintf.h" | |
| 13 #include "base/strings/utf_string_conversions.h" | |
| 14 #include "base/synchronization/waitable_event.h" | |
| 15 #include "base/threading/platform_thread.h" | |
| 16 #include "base/values.h" | |
| 17 #include "net/base/net_errors.h" | |
| 18 #include "net/base/net_log.h" | |
| 19 #include "net/base/net_log_unittest.h" | |
| 20 #include "net/base/test_completion_callback.h" | |
| 21 #include "net/dns/host_cache.h" | |
| 22 #include "net/dns/mock_host_resolver.h" | |
| 23 #include "net/proxy/proxy_info.h" | |
| 24 #include "net/proxy/proxy_resolver_error_observer.h" | |
| 25 #include "testing/gtest/include/gtest/gtest.h" | |
| 26 #include "url/gurl.h" | |
| 27 | |
| 28 namespace net { | |
| 29 | |
| 30 namespace { | |
| 31 | |
| 32 class ProxyResolverV8TracingTest : public testing::Test { | |
| 33 public: | |
| 34 void TearDown() override { | |
| 35 // Drain any pending messages, which may be left over from cancellation. | |
| 36 // This way they get reliably run as part of the current test, rather than | |
| 37 // spilling into the next test's execution. | |
| 38 base::MessageLoop::current()->RunUntilIdle(); | |
| 39 } | |
| 40 }; | |
| 41 | |
| 42 scoped_refptr<ProxyResolverScriptData> LoadScriptData(const char* filename) { | |
| 43 base::FilePath path; | |
| 44 PathService::Get(base::DIR_SOURCE_ROOT, &path); | |
| 45 path = path.AppendASCII("net"); | |
| 46 path = path.AppendASCII("data"); | |
| 47 path = path.AppendASCII("proxy_resolver_v8_tracing_unittest"); | |
| 48 path = path.AppendASCII(filename); | |
| 49 | |
| 50 // Try to read the file from disk. | |
| 51 std::string file_contents; | |
| 52 bool ok = base::ReadFileToString(path, &file_contents); | |
| 53 | |
| 54 // If we can't load the file from disk, something is misconfigured. | |
| 55 EXPECT_TRUE(ok) << "Failed to read file: " << path.value(); | |
| 56 | |
| 57 // Load the PAC script into the ProxyResolver. | |
| 58 return ProxyResolverScriptData::FromUTF8(file_contents); | |
| 59 } | |
| 60 | |
| 61 void InitResolver(ProxyResolverV8Tracing* resolver, const char* filename) { | |
| 62 TestCompletionCallback callback; | |
| 63 int rv = | |
| 64 resolver->SetPacScript(LoadScriptData(filename), callback.callback()); | |
| 65 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 66 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 67 } | |
| 68 | |
| 69 class MockErrorObserver : public ProxyResolverErrorObserver { | |
| 70 public: | |
| 71 MockErrorObserver() : event_(true, false) {} | |
| 72 | |
| 73 void OnPACScriptError(int line_number, const base::string16& error) override { | |
| 74 { | |
| 75 base::AutoLock l(lock_); | |
| 76 output += base::StringPrintf("Error: line %d: %s\n", line_number, | |
| 77 base::UTF16ToASCII(error).c_str()); | |
| 78 } | |
| 79 event_.Signal(); | |
| 80 } | |
| 81 | |
| 82 std::string GetOutput() { | |
| 83 base::AutoLock l(lock_); | |
| 84 return output; | |
| 85 } | |
| 86 | |
| 87 void WaitForOutput() { | |
| 88 event_.Wait(); | |
| 89 } | |
| 90 | |
| 91 private: | |
| 92 base::Lock lock_; | |
| 93 std::string output; | |
| 94 | |
| 95 base::WaitableEvent event_; | |
| 96 }; | |
| 97 | |
| 98 TEST_F(ProxyResolverV8TracingTest, Simple) { | |
| 99 CapturingNetLog log; | |
| 100 CapturingBoundNetLog request_log; | |
| 101 MockCachingHostResolver host_resolver; | |
| 102 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 103 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 104 | |
| 105 InitResolver(&resolver, "simple.js"); | |
| 106 | |
| 107 TestCompletionCallback callback; | |
| 108 ProxyInfo proxy_info; | |
| 109 | |
| 110 int rv = resolver.GetProxyForURL( | |
| 111 GURL("http://foo/"), &proxy_info, callback.callback(), | |
| 112 NULL, request_log.bound()); | |
| 113 | |
| 114 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 115 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 116 | |
| 117 EXPECT_EQ("foo:99", proxy_info.proxy_server().ToURI()); | |
| 118 | |
| 119 EXPECT_EQ(0u, host_resolver.num_resolve()); | |
| 120 | |
| 121 // There were no errors. | |
| 122 EXPECT_EQ("", error_observer->GetOutput()); | |
| 123 | |
| 124 // Check the NetLogs -- nothing was logged. | |
| 125 EXPECT_EQ(0u, log.GetSize()); | |
| 126 EXPECT_EQ(0u, request_log.GetSize()); | |
| 127 } | |
| 128 | |
| 129 TEST_F(ProxyResolverV8TracingTest, JavascriptError) { | |
| 130 CapturingNetLog log; | |
| 131 CapturingBoundNetLog request_log; | |
| 132 MockCachingHostResolver host_resolver; | |
| 133 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 134 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 135 | |
| 136 InitResolver(&resolver, "error.js"); | |
| 137 | |
| 138 TestCompletionCallback callback; | |
| 139 ProxyInfo proxy_info; | |
| 140 | |
| 141 int rv = resolver.GetProxyForURL( | |
| 142 GURL("http://throw-an-error/"), &proxy_info, callback.callback(), NULL, | |
| 143 request_log.bound()); | |
| 144 | |
| 145 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 146 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult()); | |
| 147 | |
| 148 EXPECT_EQ(0u, host_resolver.num_resolve()); | |
| 149 | |
| 150 EXPECT_EQ("Error: line 5: Uncaught TypeError: Cannot read property 'split' " | |
| 151 "of null\n", error_observer->GetOutput()); | |
| 152 | |
| 153 // Check the NetLogs -- there was 1 alert and 1 javascript error, and they | |
| 154 // were output to both the global log, and per-request log. | |
| 155 CapturingNetLog::CapturedEntryList entries_list[2]; | |
| 156 log.GetEntries(&entries_list[0]); | |
| 157 request_log.GetEntries(&entries_list[1]); | |
| 158 | |
| 159 for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) { | |
| 160 const CapturingNetLog::CapturedEntryList& entries = entries_list[list_i]; | |
| 161 EXPECT_EQ(2u, entries.size()); | |
| 162 EXPECT_TRUE( | |
| 163 LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 164 NetLog::PHASE_NONE)); | |
| 165 EXPECT_TRUE( | |
| 166 LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ERROR, | |
| 167 NetLog::PHASE_NONE)); | |
| 168 | |
| 169 EXPECT_EQ("{\"message\":\"Prepare to DIE!\"}", entries[0].GetParamsJson()); | |
| 170 EXPECT_EQ("{\"line_number\":5,\"message\":\"Uncaught TypeError: Cannot " | |
| 171 "read property 'split' of null\"}", entries[1].GetParamsJson()); | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) { | |
| 176 CapturingNetLog log; | |
| 177 CapturingBoundNetLog request_log; | |
| 178 MockCachingHostResolver host_resolver; | |
| 179 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 180 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 181 | |
| 182 InitResolver(&resolver, "too_many_alerts.js"); | |
| 183 | |
| 184 TestCompletionCallback callback; | |
| 185 ProxyInfo proxy_info; | |
| 186 | |
| 187 int rv = resolver.GetProxyForURL( | |
| 188 GURL("http://foo/"), | |
| 189 &proxy_info, | |
| 190 callback.callback(), | |
| 191 NULL, | |
| 192 request_log.bound()); | |
| 193 | |
| 194 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 195 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 196 | |
| 197 // Iteration1 does a DNS resolve | |
| 198 // Iteration2 exceeds the alert buffer | |
| 199 // Iteration3 runs in blocking mode and completes | |
| 200 EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI()); | |
| 201 | |
| 202 EXPECT_EQ(1u, host_resolver.num_resolve()); | |
| 203 | |
| 204 // No errors. | |
| 205 EXPECT_EQ("", error_observer->GetOutput()); | |
| 206 | |
| 207 // Check the NetLogs -- the script generated 50 alerts, which were mirrored | |
| 208 // to both the global and per-request logs. | |
| 209 CapturingNetLog::CapturedEntryList entries_list[2]; | |
| 210 log.GetEntries(&entries_list[0]); | |
| 211 request_log.GetEntries(&entries_list[1]); | |
| 212 | |
| 213 for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) { | |
| 214 const CapturingNetLog::CapturedEntryList& entries = entries_list[list_i]; | |
| 215 EXPECT_EQ(50u, entries.size()); | |
| 216 for (size_t i = 0; i < entries.size(); ++i) { | |
| 217 ASSERT_TRUE( | |
| 218 LogContainsEvent(entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 219 NetLog::PHASE_NONE)); | |
| 220 } | |
| 221 } | |
| 222 } | |
| 223 | |
| 224 // Verify that buffered alerts cannot grow unboundedly, even when the message is | |
| 225 // empty string. | |
| 226 TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) { | |
| 227 CapturingNetLog log; | |
| 228 CapturingBoundNetLog request_log; | |
| 229 MockCachingHostResolver host_resolver; | |
| 230 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 231 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 232 | |
| 233 InitResolver(&resolver, "too_many_empty_alerts.js"); | |
| 234 | |
| 235 TestCompletionCallback callback; | |
| 236 ProxyInfo proxy_info; | |
| 237 | |
| 238 int rv = resolver.GetProxyForURL( | |
| 239 GURL("http://foo/"), | |
| 240 &proxy_info, | |
| 241 callback.callback(), | |
| 242 NULL, | |
| 243 request_log.bound()); | |
| 244 | |
| 245 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 246 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 247 | |
| 248 EXPECT_EQ("foo:3", proxy_info.proxy_server().ToURI()); | |
| 249 | |
| 250 EXPECT_EQ(1u, host_resolver.num_resolve()); | |
| 251 | |
| 252 // No errors. | |
| 253 EXPECT_EQ("", error_observer->GetOutput()); | |
| 254 | |
| 255 // Check the NetLogs -- the script generated 50 alerts, which were mirrored | |
| 256 // to both the global and per-request logs. | |
| 257 CapturingNetLog::CapturedEntryList entries_list[2]; | |
| 258 log.GetEntries(&entries_list[0]); | |
| 259 request_log.GetEntries(&entries_list[1]); | |
| 260 | |
| 261 for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) { | |
| 262 const CapturingNetLog::CapturedEntryList& entries = entries_list[list_i]; | |
| 263 EXPECT_EQ(1000u, entries.size()); | |
| 264 for (size_t i = 0; i < entries.size(); ++i) { | |
| 265 ASSERT_TRUE( | |
| 266 LogContainsEvent(entries, i, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 267 NetLog::PHASE_NONE)); | |
| 268 } | |
| 269 } | |
| 270 } | |
| 271 | |
| 272 // This test runs a PAC script that issues a sequence of DNS resolves. The test | |
| 273 // verifies the final result, and that the underlying DNS resolver received | |
| 274 // the correct set of queries. | |
| 275 TEST_F(ProxyResolverV8TracingTest, Dns) { | |
| 276 CapturingNetLog log; | |
| 277 CapturingBoundNetLog request_log; | |
| 278 MockCachingHostResolver host_resolver; | |
| 279 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 280 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 281 | |
| 282 host_resolver.rules()->AddRuleForAddressFamily( | |
| 283 "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44"); | |
| 284 host_resolver.rules() | |
| 285 ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string()); | |
| 286 host_resolver.rules()->AddSimulatedFailure("host2"); | |
| 287 host_resolver.rules()->AddRule("host3", "166.155.144.33"); | |
| 288 host_resolver.rules()->AddRule("host5", "166.155.144.55"); | |
| 289 host_resolver.rules()->AddSimulatedFailure("host6"); | |
| 290 host_resolver.rules()->AddRuleForAddressFamily( | |
| 291 "*", ADDRESS_FAMILY_IPV4, "122.133.144.155"); | |
| 292 host_resolver.rules()->AddRule("*", "133.122.100.200"); | |
| 293 | |
| 294 InitResolver(&resolver, "dns.js"); | |
| 295 | |
| 296 TestCompletionCallback callback; | |
| 297 ProxyInfo proxy_info; | |
| 298 | |
| 299 int rv = resolver.GetProxyForURL( | |
| 300 GURL("http://foo/"), | |
| 301 &proxy_info, | |
| 302 callback.callback(), | |
| 303 NULL, | |
| 304 request_log.bound()); | |
| 305 | |
| 306 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 307 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 308 | |
| 309 // The test does 13 DNS resolution, however only 7 of them are unique. | |
| 310 EXPECT_EQ(7u, host_resolver.num_resolve()); | |
| 311 | |
| 312 const char* kExpectedResult = | |
| 313 "122.133.144.155-" // myIpAddress() | |
| 314 "null-" // dnsResolve('') | |
| 315 "__1_192.168.1.1-" // dnsResolveEx('host1') | |
| 316 "null-" // dnsResolve('host2') | |
| 317 "166.155.144.33-" // dnsResolve('host3') | |
| 318 "122.133.144.155-" // myIpAddress() | |
| 319 "166.155.144.33-" // dnsResolve('host3') | |
| 320 "__1_192.168.1.1-" // dnsResolveEx('host1') | |
| 321 "122.133.144.155-" // myIpAddress() | |
| 322 "null-" // dnsResolve('host2') | |
| 323 "-" // dnsResolveEx('host6') | |
| 324 "133.122.100.200-" // myIpAddressEx() | |
| 325 "166.155.144.44" // dnsResolve('host1') | |
| 326 ":99"; | |
| 327 | |
| 328 EXPECT_EQ(kExpectedResult, proxy_info.proxy_server().ToURI()); | |
| 329 | |
| 330 // No errors. | |
| 331 EXPECT_EQ("", error_observer->GetOutput()); | |
| 332 | |
| 333 // Check the NetLogs -- the script generated 1 alert, mirrored to both | |
| 334 // the per-request and global logs. | |
| 335 CapturingNetLog::CapturedEntryList entries_list[2]; | |
| 336 log.GetEntries(&entries_list[0]); | |
| 337 request_log.GetEntries(&entries_list[1]); | |
| 338 | |
| 339 for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) { | |
| 340 const CapturingNetLog::CapturedEntryList& entries = entries_list[list_i]; | |
| 341 EXPECT_EQ(1u, entries.size()); | |
| 342 EXPECT_TRUE( | |
| 343 LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 344 NetLog::PHASE_NONE)); | |
| 345 EXPECT_EQ("{\"message\":\"iteration: 7\"}", entries[0].GetParamsJson()); | |
| 346 } | |
| 347 } | |
| 348 | |
| 349 // This test runs a PAC script that does "myIpAddress()" followed by | |
| 350 // "dnsResolve()". This requires 2 restarts. However once the HostResolver's | |
| 351 // cache is warmed, subsequent calls should take 0 restarts. | |
| 352 TEST_F(ProxyResolverV8TracingTest, DnsChecksCache) { | |
| 353 CapturingNetLog log; | |
| 354 CapturingBoundNetLog request_log; | |
| 355 MockCachingHostResolver host_resolver; | |
| 356 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 357 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 358 | |
| 359 host_resolver.rules()->AddRule("foopy", "166.155.144.11"); | |
| 360 host_resolver.rules()->AddRule("*", "122.133.144.155"); | |
| 361 | |
| 362 InitResolver(&resolver, "simple_dns.js"); | |
| 363 | |
| 364 TestCompletionCallback callback1; | |
| 365 TestCompletionCallback callback2; | |
| 366 ProxyInfo proxy_info; | |
| 367 | |
| 368 int rv = resolver.GetProxyForURL( | |
| 369 GURL("http://foopy/req1"), | |
| 370 &proxy_info, | |
| 371 callback1.callback(), | |
| 372 NULL, | |
| 373 request_log.bound()); | |
| 374 | |
| 375 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 376 EXPECT_EQ(OK, callback1.WaitForResult()); | |
| 377 | |
| 378 // The test does 2 DNS resolutions. | |
| 379 EXPECT_EQ(2u, host_resolver.num_resolve()); | |
| 380 | |
| 381 // The first request took 2 restarts, hence on g_iteration=3. | |
| 382 EXPECT_EQ("166.155.144.11:3", proxy_info.proxy_server().ToURI()); | |
| 383 | |
| 384 rv = resolver.GetProxyForURL( | |
| 385 GURL("http://foopy/req2"), | |
| 386 &proxy_info, | |
| 387 callback2.callback(), | |
| 388 NULL, | |
| 389 request_log.bound()); | |
| 390 | |
| 391 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 392 EXPECT_EQ(OK, callback2.WaitForResult()); | |
| 393 | |
| 394 EXPECT_EQ(4u, host_resolver.num_resolve()); | |
| 395 | |
| 396 // This time no restarts were required, so g_iteration incremented by 1. | |
| 397 EXPECT_EQ("166.155.144.11:4", proxy_info.proxy_server().ToURI()); | |
| 398 | |
| 399 // No errors. | |
| 400 EXPECT_EQ("", error_observer->GetOutput()); | |
| 401 | |
| 402 EXPECT_EQ(0u, log.GetSize()); | |
| 403 EXPECT_EQ(0u, request_log.GetSize()); | |
| 404 } | |
| 405 | |
| 406 // This test runs a weird PAC script that was designed to defeat the DNS tracing | |
| 407 // optimization. The proxy resolver should detect the inconsistency and | |
| 408 // fall-back to synchronous mode execution. | |
| 409 TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous1) { | |
| 410 CapturingNetLog log; | |
| 411 CapturingBoundNetLog request_log; | |
| 412 MockCachingHostResolver host_resolver; | |
| 413 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 414 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 415 | |
| 416 host_resolver.rules()->AddRule("host1", "166.155.144.11"); | |
| 417 host_resolver.rules()->AddRule("crazy4", "133.199.111.4"); | |
| 418 host_resolver.rules()->AddRule("*", "122.133.144.155"); | |
| 419 | |
| 420 InitResolver(&resolver, "global_sideffects1.js"); | |
| 421 | |
| 422 TestCompletionCallback callback; | |
| 423 ProxyInfo proxy_info; | |
| 424 | |
| 425 int rv = resolver.GetProxyForURL( | |
| 426 GURL("http://foo/"), &proxy_info, callback.callback(), NULL, | |
| 427 request_log.bound()); | |
| 428 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 429 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 430 | |
| 431 // The script itself only does 2 DNS resolves per execution, however it | |
| 432 // constructs the hostname using a global counter which changes on each | |
| 433 // invocation. | |
| 434 EXPECT_EQ(3u, host_resolver.num_resolve()); | |
| 435 | |
| 436 EXPECT_EQ("166.155.144.11-133.199.111.4:100", | |
| 437 proxy_info.proxy_server().ToURI()); | |
| 438 | |
| 439 // No errors. | |
| 440 EXPECT_EQ("", error_observer->GetOutput()); | |
| 441 | |
| 442 // Check the NetLogs -- the script generated 1 alert, mirrored to both | |
| 443 // the per-request and global logs. | |
| 444 CapturingNetLog::CapturedEntryList entries_list[2]; | |
| 445 log.GetEntries(&entries_list[0]); | |
| 446 request_log.GetEntries(&entries_list[1]); | |
| 447 | |
| 448 for (size_t list_i = 0; list_i < arraysize(entries_list); list_i++) { | |
| 449 const CapturingNetLog::CapturedEntryList& entries = entries_list[list_i]; | |
| 450 EXPECT_EQ(1u, entries.size()); | |
| 451 EXPECT_TRUE( | |
| 452 LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 453 NetLog::PHASE_NONE)); | |
| 454 EXPECT_EQ("{\"message\":\"iteration: 4\"}", entries[0].GetParamsJson()); | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 // This test runs a weird PAC script that was designed to defeat the DNS tracing | |
| 459 // optimization. The proxy resolver should detect the inconsistency and | |
| 460 // fall-back to synchronous mode execution. | |
| 461 TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous2) { | |
| 462 CapturingNetLog log; | |
| 463 CapturingBoundNetLog request_log; | |
| 464 MockCachingHostResolver host_resolver; | |
| 465 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 466 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 467 | |
| 468 host_resolver.rules()->AddRule("host1", "166.155.144.11"); | |
| 469 host_resolver.rules()->AddRule("host2", "166.155.144.22"); | |
| 470 host_resolver.rules()->AddRule("host3", "166.155.144.33"); | |
| 471 host_resolver.rules()->AddRule("host4", "166.155.144.44"); | |
| 472 host_resolver.rules()->AddRule("*", "122.133.144.155"); | |
| 473 | |
| 474 InitResolver(&resolver, "global_sideffects2.js"); | |
| 475 | |
| 476 TestCompletionCallback callback; | |
| 477 ProxyInfo proxy_info; | |
| 478 | |
| 479 int rv = resolver.GetProxyForURL( | |
| 480 GURL("http://foo/"), &proxy_info, callback.callback(), NULL, | |
| 481 request_log.bound()); | |
| 482 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 483 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 484 | |
| 485 EXPECT_EQ(3u, host_resolver.num_resolve()); | |
| 486 | |
| 487 EXPECT_EQ("166.155.144.44:100", proxy_info.proxy_server().ToURI()); | |
| 488 | |
| 489 // No errors. | |
| 490 EXPECT_EQ("", error_observer->GetOutput()); | |
| 491 | |
| 492 // Check the NetLogs -- nothing was logged. | |
| 493 EXPECT_EQ(0u, log.GetSize()); | |
| 494 EXPECT_EQ(0u, request_log.GetSize()); | |
| 495 } | |
| 496 | |
| 497 // This test runs a weird PAC script that yields a never ending sequence | |
| 498 // of DNS resolves when restarting. Running it will hit the maximum | |
| 499 // DNS resolves per request limit (20) after which every DNS resolve will | |
| 500 // fail. | |
| 501 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence) { | |
| 502 CapturingNetLog log; | |
| 503 CapturingBoundNetLog request_log; | |
| 504 MockCachingHostResolver host_resolver; | |
| 505 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 506 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 507 | |
| 508 host_resolver.rules()->AddRule("host*", "166.155.144.11"); | |
| 509 host_resolver.rules()->AddRule("*", "122.133.144.155"); | |
| 510 | |
| 511 InitResolver(&resolver, "global_sideffects3.js"); | |
| 512 | |
| 513 TestCompletionCallback callback; | |
| 514 ProxyInfo proxy_info; | |
| 515 | |
| 516 int rv = resolver.GetProxyForURL( | |
| 517 GURL("http://foo/"), &proxy_info, callback.callback(), NULL, | |
| 518 request_log.bound()); | |
| 519 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 520 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 521 | |
| 522 EXPECT_EQ(20u, host_resolver.num_resolve()); | |
| 523 | |
| 524 EXPECT_EQ( | |
| 525 "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-" | |
| 526 "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-" | |
| 527 "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-" | |
| 528 "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-" | |
| 529 "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-" | |
| 530 "null:21", proxy_info.proxy_server().ToURI()); | |
| 531 | |
| 532 // No errors. | |
| 533 EXPECT_EQ("", error_observer->GetOutput()); | |
| 534 | |
| 535 // Check the NetLogs -- 1 alert was logged. | |
| 536 EXPECT_EQ(1u, log.GetSize()); | |
| 537 EXPECT_EQ(1u, request_log.GetSize()); | |
| 538 } | |
| 539 | |
| 540 // This test runs a weird PAC script that yields a never ending sequence | |
| 541 // of DNS resolves when restarting. Running it will hit the maximum | |
| 542 // DNS resolves per request limit (20) after which every DNS resolve will | |
| 543 // fail. | |
| 544 TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence2) { | |
| 545 CapturingNetLog log; | |
| 546 CapturingBoundNetLog request_log; | |
| 547 MockCachingHostResolver host_resolver; | |
| 548 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 549 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 550 | |
| 551 host_resolver.rules()->AddRule("host*", "166.155.144.11"); | |
| 552 host_resolver.rules()->AddRule("*", "122.133.144.155"); | |
| 553 | |
| 554 InitResolver(&resolver, "global_sideffects4.js"); | |
| 555 | |
| 556 TestCompletionCallback callback; | |
| 557 ProxyInfo proxy_info; | |
| 558 | |
| 559 int rv = resolver.GetProxyForURL( | |
| 560 GURL("http://foo/"), &proxy_info, callback.callback(), NULL, | |
| 561 request_log.bound()); | |
| 562 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 563 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 564 | |
| 565 EXPECT_EQ(20u, host_resolver.num_resolve()); | |
| 566 | |
| 567 EXPECT_EQ("null21:34", proxy_info.proxy_server().ToURI()); | |
| 568 | |
| 569 // No errors. | |
| 570 EXPECT_EQ("", error_observer->GetOutput()); | |
| 571 | |
| 572 // Check the NetLogs -- 1 alert was logged. | |
| 573 EXPECT_EQ(1u, log.GetSize()); | |
| 574 EXPECT_EQ(1u, request_log.GetSize()); | |
| 575 } | |
| 576 | |
| 577 void DnsDuringInitHelper(bool synchronous_host_resolver) { | |
| 578 CapturingNetLog log; | |
| 579 CapturingBoundNetLog request_log; | |
| 580 MockCachingHostResolver host_resolver; | |
| 581 host_resolver.set_synchronous_mode(synchronous_host_resolver); | |
| 582 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 583 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 584 | |
| 585 host_resolver.rules()->AddRule("host1", "91.13.12.1"); | |
| 586 host_resolver.rules()->AddRule("host2", "91.13.12.2"); | |
| 587 | |
| 588 InitResolver(&resolver, "dns_during_init.js"); | |
| 589 | |
| 590 // Initialization did 2 dnsResolves. | |
| 591 EXPECT_EQ(2u, host_resolver.num_resolve()); | |
| 592 | |
| 593 host_resolver.rules()->ClearRules(); | |
| 594 host_resolver.GetHostCache()->clear(); | |
| 595 | |
| 596 host_resolver.rules()->AddRule("host1", "145.88.13.3"); | |
| 597 host_resolver.rules()->AddRule("host2", "137.89.8.45"); | |
| 598 | |
| 599 TestCompletionCallback callback; | |
| 600 ProxyInfo proxy_info; | |
| 601 | |
| 602 int rv = resolver.GetProxyForURL( | |
| 603 GURL("http://foo/"), &proxy_info, callback.callback(), NULL, | |
| 604 request_log.bound()); | |
| 605 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 606 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 607 | |
| 608 // Fetched host1 and host2 again, since the ones done during initialization | |
| 609 // should not have been cached. | |
| 610 EXPECT_EQ(4u, host_resolver.num_resolve()); | |
| 611 | |
| 612 EXPECT_EQ("91.13.12.1-91.13.12.2-145.88.13.3-137.89.8.45:99", | |
| 613 proxy_info.proxy_server().ToURI()); | |
| 614 | |
| 615 // Check the NetLogs -- the script generated 2 alerts during initialization. | |
| 616 EXPECT_EQ(0u, request_log.GetSize()); | |
| 617 CapturingNetLog::CapturedEntryList entries; | |
| 618 log.GetEntries(&entries); | |
| 619 | |
| 620 ASSERT_EQ(2u, entries.size()); | |
| 621 EXPECT_TRUE( | |
| 622 LogContainsEvent(entries, 0, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 623 NetLog::PHASE_NONE)); | |
| 624 EXPECT_TRUE( | |
| 625 LogContainsEvent(entries, 1, NetLog::TYPE_PAC_JAVASCRIPT_ALERT, | |
| 626 NetLog::PHASE_NONE)); | |
| 627 | |
| 628 EXPECT_EQ("{\"message\":\"Watsup\"}", entries[0].GetParamsJson()); | |
| 629 EXPECT_EQ("{\"message\":\"Watsup2\"}", entries[1].GetParamsJson()); | |
| 630 } | |
| 631 | |
| 632 // Tests a PAC script which does DNS resolves during initialization. | |
| 633 TEST_F(ProxyResolverV8TracingTest, DnsDuringInit) { | |
| 634 // Test with both both a host resolver that always completes asynchronously, | |
| 635 // and then again with one that completes synchronously. | |
| 636 DnsDuringInitHelper(false); | |
| 637 DnsDuringInitHelper(true); | |
| 638 } | |
| 639 | |
| 640 void CrashCallback(int) { | |
| 641 // Be extra sure that if the callback ever gets invoked, the test will fail. | |
| 642 CHECK(false); | |
| 643 } | |
| 644 | |
| 645 // Start some requests, cancel them all, and then destroy the resolver. | |
| 646 // Note the execution order for this test can vary. Since multiple | |
| 647 // threads are involved, the cancellation may be received a different | |
| 648 // times. | |
| 649 TEST_F(ProxyResolverV8TracingTest, CancelAll) { | |
| 650 MockCachingHostResolver host_resolver; | |
| 651 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 652 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 653 | |
| 654 host_resolver.rules()->AddSimulatedFailure("*"); | |
| 655 | |
| 656 InitResolver(&resolver, "dns.js"); | |
| 657 | |
| 658 const size_t kNumRequests = 5; | |
| 659 ProxyInfo proxy_info[kNumRequests]; | |
| 660 ProxyResolver::RequestHandle request[kNumRequests]; | |
| 661 | |
| 662 for (size_t i = 0; i < kNumRequests; ++i) { | |
| 663 int rv = resolver.GetProxyForURL( | |
| 664 GURL("http://foo/"), &proxy_info[i], | |
| 665 base::Bind(&CrashCallback), &request[i], BoundNetLog()); | |
| 666 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 667 } | |
| 668 | |
| 669 for (size_t i = 0; i < kNumRequests; ++i) { | |
| 670 resolver.CancelRequest(request[i]); | |
| 671 } | |
| 672 } | |
| 673 | |
| 674 // Note the execution order for this test can vary. Since multiple | |
| 675 // threads are involved, the cancellation may be received a different | |
| 676 // times. | |
| 677 TEST_F(ProxyResolverV8TracingTest, CancelSome) { | |
| 678 MockCachingHostResolver host_resolver; | |
| 679 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 680 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 681 | |
| 682 host_resolver.rules()->AddSimulatedFailure("*"); | |
| 683 | |
| 684 InitResolver(&resolver, "dns.js"); | |
| 685 | |
| 686 ProxyInfo proxy_info1; | |
| 687 ProxyInfo proxy_info2; | |
| 688 ProxyResolver::RequestHandle request1; | |
| 689 ProxyResolver::RequestHandle request2; | |
| 690 TestCompletionCallback callback; | |
| 691 | |
| 692 int rv = resolver.GetProxyForURL( | |
| 693 GURL("http://foo/"), &proxy_info1, | |
| 694 base::Bind(&CrashCallback), &request1, BoundNetLog()); | |
| 695 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 696 | |
| 697 rv = resolver.GetProxyForURL( | |
| 698 GURL("http://foo/"), &proxy_info2, | |
| 699 callback.callback(), &request2, BoundNetLog()); | |
| 700 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 701 | |
| 702 resolver.CancelRequest(request1); | |
| 703 | |
| 704 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 705 } | |
| 706 | |
| 707 // Cancel a request after it has finished running on the worker thread, and has | |
| 708 // posted a task the completion task back to origin thread. | |
| 709 TEST_F(ProxyResolverV8TracingTest, CancelWhilePendingCompletionTask) { | |
| 710 MockCachingHostResolver host_resolver; | |
| 711 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 712 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 713 | |
| 714 host_resolver.rules()->AddSimulatedFailure("*"); | |
| 715 | |
| 716 InitResolver(&resolver, "error.js"); | |
| 717 | |
| 718 ProxyInfo proxy_info1; | |
| 719 ProxyInfo proxy_info2; | |
| 720 ProxyInfo proxy_info3; | |
| 721 ProxyResolver::RequestHandle request1; | |
| 722 ProxyResolver::RequestHandle request2; | |
| 723 ProxyResolver::RequestHandle request3; | |
| 724 TestCompletionCallback callback; | |
| 725 | |
| 726 int rv = resolver.GetProxyForURL( | |
| 727 GURL("http://foo/"), &proxy_info1, | |
| 728 base::Bind(&CrashCallback), &request1, BoundNetLog()); | |
| 729 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 730 | |
| 731 rv = resolver.GetProxyForURL( | |
| 732 GURL("http://throw-an-error/"), &proxy_info2, | |
| 733 callback.callback(), &request2, BoundNetLog()); | |
| 734 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 735 | |
| 736 // Wait until the first request has finished running on the worker thread. | |
| 737 // (The second request will output an error). | |
| 738 error_observer->WaitForOutput(); | |
| 739 | |
| 740 // Cancel the first request, while it has a pending completion task on | |
| 741 // the origin thread. | |
| 742 resolver.CancelRequest(request1); | |
| 743 | |
| 744 EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult()); | |
| 745 | |
| 746 // Start another request, to make sure it is able to complete. | |
| 747 rv = resolver.GetProxyForURL( | |
| 748 GURL("http://i-have-no-idea-what-im-doing/"), &proxy_info3, | |
| 749 callback.callback(), &request3, BoundNetLog()); | |
| 750 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 751 | |
| 752 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 753 | |
| 754 EXPECT_EQ("i-approve-this-message:42", | |
| 755 proxy_info3.proxy_server().ToURI()); | |
| 756 } | |
| 757 | |
| 758 // This implementation of HostResolver allows blocking until a resolve request | |
| 759 // has been received. The resolve requests it receives will never be completed. | |
| 760 class BlockableHostResolver : public HostResolver { | |
| 761 public: | |
| 762 BlockableHostResolver() | |
| 763 : num_cancelled_requests_(0), waiting_for_resolve_(false) {} | |
| 764 | |
| 765 int Resolve(const RequestInfo& info, | |
| 766 RequestPriority priority, | |
| 767 AddressList* addresses, | |
| 768 const CompletionCallback& callback, | |
| 769 RequestHandle* out_req, | |
| 770 const BoundNetLog& net_log) override { | |
| 771 EXPECT_FALSE(callback.is_null()); | |
| 772 EXPECT_TRUE(out_req); | |
| 773 | |
| 774 if (!action_.is_null()) | |
| 775 action_.Run(); | |
| 776 | |
| 777 // Indicate to the caller that a request was received. | |
| 778 EXPECT_TRUE(waiting_for_resolve_); | |
| 779 base::MessageLoop::current()->Quit(); | |
| 780 | |
| 781 // This line is intentionally after action_.Run(), since one of the | |
| 782 // tests does a cancellation inside of Resolve(), and it is more | |
| 783 // interesting if *out_req hasn't been written yet at that point. | |
| 784 *out_req = reinterpret_cast<RequestHandle*>(1); // Magic value. | |
| 785 | |
| 786 // Return ERR_IO_PENDING as this request will NEVER be completed. | |
| 787 // Expectation is for the caller to later cancel the request. | |
| 788 return ERR_IO_PENDING; | |
| 789 } | |
| 790 | |
| 791 int ResolveFromCache(const RequestInfo& info, | |
| 792 AddressList* addresses, | |
| 793 const BoundNetLog& net_log) override { | |
| 794 NOTREACHED(); | |
| 795 return ERR_DNS_CACHE_MISS; | |
| 796 } | |
| 797 | |
| 798 void CancelRequest(RequestHandle req) override { | |
| 799 EXPECT_EQ(reinterpret_cast<RequestHandle*>(1), req); | |
| 800 num_cancelled_requests_++; | |
| 801 } | |
| 802 | |
| 803 void SetAction(const base::Callback<void(void)>& action) { | |
| 804 action_ = action; | |
| 805 } | |
| 806 | |
| 807 // Waits until Resolve() has been called. | |
| 808 void WaitUntilRequestIsReceived() { | |
| 809 waiting_for_resolve_ = true; | |
| 810 base::MessageLoop::current()->Run(); | |
| 811 DCHECK(waiting_for_resolve_); | |
| 812 waiting_for_resolve_ = false; | |
| 813 } | |
| 814 | |
| 815 int num_cancelled_requests() const { | |
| 816 return num_cancelled_requests_; | |
| 817 } | |
| 818 | |
| 819 private: | |
| 820 int num_cancelled_requests_; | |
| 821 bool waiting_for_resolve_; | |
| 822 base::Callback<void(void)> action_; | |
| 823 }; | |
| 824 | |
| 825 // This cancellation test exercises a more predictable cancellation codepath -- | |
| 826 // when the request has an outstanding DNS request in flight. | |
| 827 TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) { | |
| 828 BlockableHostResolver host_resolver; | |
| 829 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 830 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 831 | |
| 832 InitResolver(&resolver, "dns.js"); | |
| 833 | |
| 834 ProxyInfo proxy_info1; | |
| 835 ProxyInfo proxy_info2; | |
| 836 ProxyResolver::RequestHandle request1; | |
| 837 ProxyResolver::RequestHandle request2; | |
| 838 | |
| 839 int rv = resolver.GetProxyForURL( | |
| 840 GURL("http://foo/req1"), &proxy_info1, | |
| 841 base::Bind(&CrashCallback), &request1, BoundNetLog()); | |
| 842 | |
| 843 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 844 | |
| 845 host_resolver.WaitUntilRequestIsReceived(); | |
| 846 | |
| 847 rv = resolver.GetProxyForURL( | |
| 848 GURL("http://foo/req2"), &proxy_info2, | |
| 849 base::Bind(&CrashCallback), &request2, BoundNetLog()); | |
| 850 | |
| 851 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 852 | |
| 853 host_resolver.WaitUntilRequestIsReceived(); | |
| 854 | |
| 855 resolver.CancelRequest(request1); | |
| 856 resolver.CancelRequest(request2); | |
| 857 | |
| 858 EXPECT_EQ(2, host_resolver.num_cancelled_requests()); | |
| 859 | |
| 860 // After leaving this scope, the ProxyResolver is destroyed. | |
| 861 // This should not cause any problems, as the outstanding work | |
| 862 // should have been cancelled. | |
| 863 } | |
| 864 | |
| 865 void CancelRequestAndPause(ProxyResolverV8Tracing* resolver, | |
| 866 ProxyResolver::RequestHandle request) { | |
| 867 resolver->CancelRequest(request); | |
| 868 | |
| 869 // Sleep for a little bit. This makes it more likely for the worker | |
| 870 // thread to have returned from its call, and serves as a regression | |
| 871 // test for http://crbug.com/173373. | |
| 872 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30)); | |
| 873 } | |
| 874 | |
| 875 // In non-blocking mode, the worker thread actually does block for | |
| 876 // a short time to see if the result is in the DNS cache. Test | |
| 877 // cancellation while the worker thread is waiting on this event. | |
| 878 TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns) { | |
| 879 BlockableHostResolver host_resolver; | |
| 880 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 881 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 882 | |
| 883 InitResolver(&resolver, "dns.js"); | |
| 884 | |
| 885 ProxyInfo proxy_info; | |
| 886 ProxyResolver::RequestHandle request; | |
| 887 | |
| 888 int rv = resolver.GetProxyForURL( | |
| 889 GURL("http://foo/"), &proxy_info, | |
| 890 base::Bind(&CrashCallback), &request, BoundNetLog()); | |
| 891 | |
| 892 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 893 | |
| 894 host_resolver.SetAction( | |
| 895 base::Bind(CancelRequestAndPause, &resolver, request)); | |
| 896 | |
| 897 host_resolver.WaitUntilRequestIsReceived(); | |
| 898 | |
| 899 // At this point the host resolver ran Resolve(), and should have cancelled | |
| 900 // the request. | |
| 901 | |
| 902 EXPECT_EQ(1, host_resolver.num_cancelled_requests()); | |
| 903 } | |
| 904 | |
| 905 // Cancel the request while there is a pending DNS request, however before | |
| 906 // the request is sent to the host resolver. | |
| 907 TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) { | |
| 908 MockCachingHostResolver host_resolver; | |
| 909 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 910 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 911 | |
| 912 InitResolver(&resolver, "dns.js"); | |
| 913 | |
| 914 ProxyInfo proxy_info; | |
| 915 ProxyResolver::RequestHandle request; | |
| 916 | |
| 917 int rv = resolver.GetProxyForURL( | |
| 918 GURL("http://foo/"), &proxy_info, | |
| 919 base::Bind(&CrashCallback), &request, BoundNetLog()); | |
| 920 | |
| 921 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 922 | |
| 923 // Wait a bit, so the DNS task has hopefully been posted. The test will | |
| 924 // work whatever the delay is here, but it is most useful if the delay | |
| 925 // is large enough to allow a task to be posted back. | |
| 926 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); | |
| 927 resolver.CancelRequest(request); | |
| 928 | |
| 929 EXPECT_EQ(0u, host_resolver.num_resolve()); | |
| 930 } | |
| 931 | |
| 932 TEST_F(ProxyResolverV8TracingTest, CancelSetPacWhileOutstandingBlockingDns) { | |
| 933 BlockableHostResolver host_resolver; | |
| 934 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 935 | |
| 936 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, NULL); | |
| 937 | |
| 938 int rv = | |
| 939 resolver.SetPacScript(LoadScriptData("dns_during_init.js"), | |
| 940 base::Bind(&CrashCallback)); | |
| 941 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 942 | |
| 943 host_resolver.WaitUntilRequestIsReceived(); | |
| 944 | |
| 945 resolver.CancelSetPacScript(); | |
| 946 EXPECT_EQ(1, host_resolver.num_cancelled_requests()); | |
| 947 } | |
| 948 | |
| 949 // This tests that the execution of a PAC script is terminated when the DNS | |
| 950 // dependencies are missing. If the test fails, then it will hang. | |
| 951 TEST_F(ProxyResolverV8TracingTest, Terminate) { | |
| 952 CapturingNetLog log; | |
| 953 CapturingBoundNetLog request_log; | |
| 954 MockCachingHostResolver host_resolver; | |
| 955 MockErrorObserver* error_observer = new MockErrorObserver; | |
| 956 ProxyResolverV8Tracing resolver(&host_resolver, error_observer, &log); | |
| 957 | |
| 958 host_resolver.rules()->AddRule("host1", "182.111.0.222"); | |
| 959 host_resolver.rules()->AddRule("host2", "111.33.44.55"); | |
| 960 | |
| 961 InitResolver(&resolver, "terminate.js"); | |
| 962 | |
| 963 TestCompletionCallback callback; | |
| 964 ProxyInfo proxy_info; | |
| 965 | |
| 966 int rv = resolver.GetProxyForURL( | |
| 967 GURL("http://foopy/req1"), | |
| 968 &proxy_info, | |
| 969 callback.callback(), | |
| 970 NULL, | |
| 971 request_log.bound()); | |
| 972 | |
| 973 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 974 EXPECT_EQ(OK, callback.WaitForResult()); | |
| 975 | |
| 976 // The test does 2 DNS resolutions. | |
| 977 EXPECT_EQ(2u, host_resolver.num_resolve()); | |
| 978 | |
| 979 EXPECT_EQ("foopy:3", proxy_info.proxy_server().ToURI()); | |
| 980 | |
| 981 // No errors. | |
| 982 EXPECT_EQ("", error_observer->GetOutput()); | |
| 983 | |
| 984 EXPECT_EQ(0u, log.GetSize()); | |
| 985 EXPECT_EQ(0u, request_log.GetSize()); | |
| 986 } | |
| 987 | |
| 988 // Tests that multiple instances of ProxyResolverV8Tracing can coexist and run | |
| 989 // correctly at the same time. This is relevant because at the moment (time | |
| 990 // this test was written) each ProxyResolverV8Tracing creates its own thread to | |
| 991 // run V8 on, however each thread is operating on the same v8::Isolate. | |
| 992 TEST_F(ProxyResolverV8TracingTest, MultipleResolvers) { | |
| 993 // ------------------------ | |
| 994 // Setup resolver0 | |
| 995 // ------------------------ | |
| 996 MockHostResolver host_resolver0; | |
| 997 host_resolver0.rules()->AddRuleForAddressFamily( | |
| 998 "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44"); | |
| 999 host_resolver0.rules() | |
| 1000 ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string()); | |
| 1001 host_resolver0.rules()->AddSimulatedFailure("host2"); | |
| 1002 host_resolver0.rules()->AddRule("host3", "166.155.144.33"); | |
| 1003 host_resolver0.rules()->AddRule("host5", "166.155.144.55"); | |
| 1004 host_resolver0.rules()->AddSimulatedFailure("host6"); | |
| 1005 host_resolver0.rules()->AddRuleForAddressFamily( | |
| 1006 "*", ADDRESS_FAMILY_IPV4, "122.133.144.155"); | |
| 1007 host_resolver0.rules()->AddRule("*", "133.122.100.200"); | |
| 1008 ProxyResolverV8Tracing resolver0( | |
| 1009 &host_resolver0, new MockErrorObserver, NULL); | |
| 1010 InitResolver(&resolver0, "dns.js"); | |
| 1011 | |
| 1012 // ------------------------ | |
| 1013 // Setup resolver1 | |
| 1014 // ------------------------ | |
| 1015 ProxyResolverV8Tracing resolver1( | |
| 1016 &host_resolver0, new MockErrorObserver, NULL); | |
| 1017 InitResolver(&resolver1, "dns.js"); | |
| 1018 | |
| 1019 // ------------------------ | |
| 1020 // Setup resolver2 | |
| 1021 // ------------------------ | |
| 1022 ProxyResolverV8Tracing resolver2( | |
| 1023 &host_resolver0, new MockErrorObserver, NULL); | |
| 1024 InitResolver(&resolver2, "simple.js"); | |
| 1025 | |
| 1026 // ------------------------ | |
| 1027 // Setup resolver3 | |
| 1028 // ------------------------ | |
| 1029 MockHostResolver host_resolver3; | |
| 1030 host_resolver3.rules()->AddRule("foo", "166.155.144.33"); | |
| 1031 ProxyResolverV8Tracing resolver3( | |
| 1032 &host_resolver3, new MockErrorObserver, NULL); | |
| 1033 InitResolver(&resolver3, "simple_dns.js"); | |
| 1034 | |
| 1035 // ------------------------ | |
| 1036 // Queue up work for each resolver (which will be running in parallel). | |
| 1037 // ------------------------ | |
| 1038 | |
| 1039 ProxyResolverV8Tracing* resolver[] = { | |
| 1040 &resolver0, &resolver1, &resolver2, &resolver3, | |
| 1041 }; | |
| 1042 | |
| 1043 const size_t kNumResolvers = arraysize(resolver); | |
| 1044 const size_t kNumIterations = 20; | |
| 1045 const size_t kNumResults = kNumResolvers * kNumIterations; | |
| 1046 TestCompletionCallback callback[kNumResults]; | |
| 1047 ProxyInfo proxy_info[kNumResults]; | |
| 1048 | |
| 1049 for (size_t i = 0; i < kNumResults; ++i) { | |
| 1050 size_t resolver_i = i % kNumResolvers; | |
| 1051 int rv = resolver[resolver_i]->GetProxyForURL( | |
| 1052 GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL, | |
| 1053 BoundNetLog()); | |
| 1054 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 1055 } | |
| 1056 | |
| 1057 // ------------------------ | |
| 1058 // Verify all of the results. | |
| 1059 // ------------------------ | |
| 1060 | |
| 1061 const char* kExpectedForDnsJs = | |
| 1062 "122.133.144.155-" // myIpAddress() | |
| 1063 "null-" // dnsResolve('') | |
| 1064 "__1_192.168.1.1-" // dnsResolveEx('host1') | |
| 1065 "null-" // dnsResolve('host2') | |
| 1066 "166.155.144.33-" // dnsResolve('host3') | |
| 1067 "122.133.144.155-" // myIpAddress() | |
| 1068 "166.155.144.33-" // dnsResolve('host3') | |
| 1069 "__1_192.168.1.1-" // dnsResolveEx('host1') | |
| 1070 "122.133.144.155-" // myIpAddress() | |
| 1071 "null-" // dnsResolve('host2') | |
| 1072 "-" // dnsResolveEx('host6') | |
| 1073 "133.122.100.200-" // myIpAddressEx() | |
| 1074 "166.155.144.44" // dnsResolve('host1') | |
| 1075 ":99"; | |
| 1076 | |
| 1077 for (size_t i = 0; i < kNumResults; ++i) { | |
| 1078 size_t resolver_i = i % kNumResolvers; | |
| 1079 EXPECT_EQ(OK, callback[i].WaitForResult()); | |
| 1080 | |
| 1081 std::string proxy_uri = proxy_info[i].proxy_server().ToURI(); | |
| 1082 | |
| 1083 if (resolver_i == 0 || resolver_i == 1) { | |
| 1084 EXPECT_EQ(kExpectedForDnsJs, proxy_uri); | |
| 1085 } else if (resolver_i == 2) { | |
| 1086 EXPECT_EQ("foo:99", proxy_uri); | |
| 1087 } else if (resolver_i == 3) { | |
| 1088 EXPECT_EQ("166.155.144.33:", | |
| 1089 proxy_uri.substr(0, proxy_uri.find(':') + 1)); | |
| 1090 } else { | |
| 1091 NOTREACHED(); | |
| 1092 } | |
| 1093 } | |
| 1094 } | |
| 1095 | |
| 1096 } // namespace | |
| 1097 | |
| 1098 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master