1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105 |
- // 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 "services/proxy_resolver/proxy_resolver_v8_tracing.h"
- #include <string>
- #include <utility>
- #include <vector>
- #include "base/bind.h"
- #include "base/files/file_util.h"
- #include "base/memory/raw_ptr.h"
- #include "base/path_service.h"
- #include "base/run_loop.h"
- #include "base/strings/string_number_conversions.h"
- #include "base/strings/utf_string_conversions.h"
- #include "base/synchronization/waitable_event.h"
- #include "base/test/task_environment.h"
- #include "base/threading/platform_thread.h"
- #include "base/threading/thread_checker.h"
- #include "base/values.h"
- #include "net/base/net_errors.h"
- #include "net/base/network_interfaces.h"
- #include "net/base/network_isolation_key.h"
- #include "net/base/proxy_string_util.h"
- #include "net/base/test_completion_callback.h"
- #include "net/log/net_log_with_source.h"
- #include "net/proxy_resolution/proxy_info.h"
- #include "net/proxy_resolution/proxy_resolve_dns_operation.h"
- #include "net/test/event_waiter.h"
- #include "net/test/gtest_util.h"
- #include "services/proxy_resolver/mock_proxy_host_resolver.h"
- #include "testing/gmock/include/gmock/gmock.h"
- #include "testing/gtest/include/gtest/gtest.h"
- #include "url/gurl.h"
- #include "url/origin.h"
- using net::test::IsError;
- using net::test::IsOk;
- namespace proxy_resolver {
- namespace {
- class ProxyResolverV8TracingTest : 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.
- base::RunLoop().RunUntilIdle();
- }
- base::test::TaskEnvironment task_environment_;
- };
- scoped_refptr<net::PacFileData> LoadScriptData(const char* filename) {
- base::FilePath path;
- base::PathService::Get(base::DIR_SOURCE_ROOT, &path);
- path = path.AppendASCII("services");
- path = path.AppendASCII("proxy_resolver");
- path = path.AppendASCII("test");
- path = path.AppendASCII("data");
- path = path.AppendASCII("proxy_resolver_v8_tracing_unittest");
- path = path.AppendASCII(filename);
- // Try to read the file from disk.
- std::string file_contents;
- bool ok = base::ReadFileToString(path, &file_contents);
- // If we can't load the file from disk, something is misconfigured.
- EXPECT_TRUE(ok) << "Failed to read file: " << path.value();
- // Load the PAC script into the net::ProxyResolver.
- return net::PacFileData::FromUTF8(file_contents);
- }
- class MockBindings {
- public:
- explicit MockBindings(ProxyHostResolver* host_resolver)
- : host_resolver_(host_resolver) {}
- void Alert(const std::u16string& message) {
- alerts_.push_back(base::UTF16ToASCII(message));
- }
- void OnError(int line_number, const std::u16string& error) {
- waiter_.NotifyEvent(EVENT_ERROR);
- errors_.push_back(std::make_pair(line_number, base::UTF16ToASCII(error)));
- if (!error_callback_.is_null())
- std::move(error_callback_).Run();
- }
- ProxyHostResolver* host_resolver() { return host_resolver_; }
- std::vector<std::string> GetAlerts() { return alerts_; }
- std::vector<std::pair<int, std::string>> GetErrors() { return errors_; }
- void RunOnError(base::OnceClosure callback) {
- error_callback_ = std::move(callback);
- waiter_.WaitForEvent(EVENT_ERROR);
- }
- std::unique_ptr<ProxyResolverV8Tracing::Bindings> CreateBindings() {
- return std::make_unique<ForwardingBindings>(this);
- }
- private:
- class ForwardingBindings : public ProxyResolverV8Tracing::Bindings {
- public:
- explicit ForwardingBindings(MockBindings* bindings) : bindings_(bindings) {}
- // ProxyResolverV8Tracing::Bindings overrides.
- void Alert(const std::u16string& message) override {
- DCHECK(thread_checker_.CalledOnValidThread());
- bindings_->Alert(message);
- }
- void OnError(int line_number, const std::u16string& error) override {
- DCHECK(thread_checker_.CalledOnValidThread());
- bindings_->OnError(line_number, error);
- }
- net::NetLogWithSource GetNetLogWithSource() override {
- DCHECK(thread_checker_.CalledOnValidThread());
- return net::NetLogWithSource();
- }
- ProxyHostResolver* GetHostResolver() override {
- DCHECK(thread_checker_.CalledOnValidThread());
- return bindings_->host_resolver();
- }
- private:
- raw_ptr<MockBindings> bindings_;
- base::ThreadChecker thread_checker_;
- };
- enum Event {
- EVENT_ERROR,
- };
- std::vector<std::string> alerts_;
- std::vector<std::pair<int, std::string>> errors_;
- const raw_ptr<ProxyHostResolver> host_resolver_;
- base::OnceClosure error_callback_;
- net::EventWaiter<Event> waiter_;
- };
- std::unique_ptr<ProxyResolverV8Tracing> CreateResolver(
- std::unique_ptr<ProxyResolverV8Tracing::Bindings> bindings,
- const char* filename) {
- std::unique_ptr<ProxyResolverV8Tracing> resolver;
- std::unique_ptr<ProxyResolverV8TracingFactory> factory(
- ProxyResolverV8TracingFactory::Create());
- net::TestCompletionCallback callback;
- std::unique_ptr<net::ProxyResolverFactory::Request> request;
- factory->CreateProxyResolverV8Tracing(LoadScriptData(filename),
- std::move(bindings), &resolver,
- callback.callback(), &request);
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_TRUE(resolver);
- return resolver;
- }
- TEST_F(ProxyResolverV8TracingTest, Simple) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "simple.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ("foo:99", ProxyServerToProxyUri(proxy_info.proxy_server()));
- 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) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "error.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(
- GURL("http://throw-an-error/"), net::NetworkIsolationKey(), &proxy_info,
- callback.callback(), &req, mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsError(net::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 properties of null (reading 'split')",
- mock_bindings.GetErrors()[0].second);
- }
- TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "too_many_alerts.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, 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", ProxyServerToProxyUri(proxy_info.proxy_server()));
- EXPECT_EQ(1u, host_resolver.num_resolve());
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- // Check the alerts -- the script generated 50 alerts.
- std::vector<std::string> alerts = mock_bindings.GetAlerts();
- ASSERT_EQ(50u, alerts.size());
- for (size_t i = 0; i < alerts.size(); i++) {
- EXPECT_EQ("Gee, all these alerts are silly!", alerts[i]);
- }
- }
- // Verify that buffered alerts cannot grow unboundedly, even when the message is
- // empty string.
- TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver = CreateResolver(
- mock_bindings.CreateBindings(), "too_many_empty_alerts.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ("foo:3", ProxyServerToProxyUri(proxy_info.proxy_server()));
- EXPECT_EQ(1u, host_resolver.num_resolve());
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- // Check the alerts -- the script generated 1000 alerts.
- std::vector<std::string> alerts = mock_bindings.GetAlerts();
- ASSERT_EQ(1000u, alerts.size());
- for (size_t i = 0; i < alerts.size(); i++) {
- EXPECT_EQ("", alerts[i]);
- }
- }
- // This test runs a PAC script that issues a sequence of DNS resolves. The test
- // verifies the final result, and that the underlying DNS resolver received
- // the correct set of queries.
- TEST_F(ProxyResolverV8TracingTest, Dns) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS,
- net::NetworkIsolationKey(), {net::IPAddress(122, 133, 144, 155)});
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS_EX,
- net::NetworkIsolationKey(), {net::IPAddress(133, 122, 100, 200)});
- host_resolver.SetError("", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey());
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 44)});
- net::IPAddress v6_local;
- ASSERT_TRUE(v6_local.AssignFromIPLiteral("::1"));
- host_resolver.SetResult(
- "host1", net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
- net::NetworkIsolationKey(), {v6_local, net::IPAddress(192, 168, 1, 1)});
- host_resolver.SetError("host2", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey());
- host_resolver.SetResult("host3", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 33)});
- host_resolver.SetError("host6", net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
- net::NetworkIsolationKey());
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, 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('')
- "__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')
- ".test:99";
- EXPECT_EQ(kExpectedResult, ProxyServerToProxyUri(proxy_info.proxy_server()));
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- // The script generated 1 alert.
- ASSERT_EQ(1u, mock_bindings.GetAlerts().size());
- EXPECT_EQ("iteration: 7", mock_bindings.GetAlerts()[0]);
- }
- // This test runs a weird PAC script that was designed to defeat the DNS tracing
- // optimization. The proxy resolver should detect the inconsistency and
- // fall-back to synchronous mode execution.
- TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous1) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 11)});
- host_resolver.SetResult("crazy4", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(133, 199, 111, 4)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "global_sideffects1.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, 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.test:100",
- ProxyServerToProxyUri(proxy_info.proxy_server()));
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- ASSERT_EQ(1u, mock_bindings.GetAlerts().size());
- EXPECT_EQ("iteration: 4", mock_bindings.GetAlerts()[0]);
- }
- // This test runs a weird PAC script that was designed to defeat the DNS tracing
- // optimization. The proxy resolver should detect the inconsistency and
- // fall-back to synchronous mode execution.
- TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous2) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 11)});
- host_resolver.SetResult("host2", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 22)});
- host_resolver.SetResult("host3", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 33)});
- host_resolver.SetResult("host4", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 44)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "global_sideffects2.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ(3u, host_resolver.num_resolve());
- EXPECT_EQ("166.155.144.44.test:100",
- ProxyServerToProxyUri(proxy_info.proxy_server()));
- // 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) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- for (int i = 0; i < 21; ++i) {
- host_resolver.SetResult("host" + base::NumberToString(i),
- net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 11)});
- }
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "global_sideffects3.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, 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-"
- "166.155.144.11-166.155.144.11-166.155.144.11-166.155.144.11-"
- "null:21",
- ProxyServerToProxyUri(proxy_info.proxy_server()));
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- // 1 alert.
- EXPECT_EQ(1u, mock_bindings.GetAlerts().size());
- EXPECT_EQ("iteration: 21", mock_bindings.GetAlerts()[0]);
- }
- // 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, InfiniteDNSSequence2) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS,
- net::NetworkIsolationKey(), {net::IPAddress(122, 133, 144, 155)});
- for (int i = 0; i < 21; ++i) {
- host_resolver.SetResult("host" + base::NumberToString(i),
- net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 11)});
- }
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "global_sideffects4.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ(20u, host_resolver.num_resolve());
- EXPECT_EQ("null21:34", ProxyServerToProxyUri(proxy_info.proxy_server()));
- // No errors.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- // 1 alert.
- EXPECT_EQ(1u, mock_bindings.GetAlerts().size());
- EXPECT_EQ("iteration: 21", mock_bindings.GetAlerts()[0]);
- }
- void DnsDuringInitHelper(bool synchronous_host_resolver) {
- MockProxyHostResolver host_resolver(synchronous_host_resolver);
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(91, 13, 12, 1)});
- host_resolver.SetResult("host2", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(91, 13, 12, 2)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns_during_init.js");
- // Initialization did 2 dnsResolves.
- EXPECT_EQ(2u, host_resolver.num_resolve());
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(145, 88, 13, 3)});
- host_resolver.SetResult("host2", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(137, 89, 8, 45)});
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, 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.test:99",
- ProxyServerToProxyUri(proxy_info.proxy_server()));
- // 2 alerts.
- ASSERT_EQ(2u, mock_bindings.GetAlerts().size());
- EXPECT_EQ("Watsup", mock_bindings.GetAlerts()[0]);
- EXPECT_EQ("Watsup2", mock_bindings.GetAlerts()[1]);
- }
- // Tests a PAC script which does DNS resolves during initialization.
- TEST_F(ProxyResolverV8TracingTest, DnsDuringInit) {
- // Test with both both a host resolver that always completes asynchronously,
- // and then again with one that completes synchronously.
- DnsDuringInitHelper(false);
- DnsDuringInitHelper(true);
- }
- void CrashCallback(int) {
- // Be extra sure that if the callback ever gets invoked, the test will fail.
- CHECK(false);
- }
- // Start some requests, cancel them all, and then destroy the resolver.
- // 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, CancelAll) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.FailAll();
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- const size_t kNumRequests = 5;
- net::ProxyInfo proxy_info[kNumRequests];
- std::unique_ptr<net::ProxyResolver::Request> request[kNumRequests];
- for (size_t i = 0; i < kNumRequests; ++i) {
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info[i], base::BindOnce(&CrashCallback),
- &request[i], mock_bindings.CreateBindings());
- }
- for (size_t i = 0; i < kNumRequests; ++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) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.FailAll();
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- net::ProxyInfo proxy_info1;
- net::ProxyInfo proxy_info2;
- std::unique_ptr<net::ProxyResolver::Request> request1;
- std::unique_ptr<net::ProxyResolver::Request> request2;
- net::TestCompletionCallback callback;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info1, base::BindOnce(&CrashCallback),
- &request1, mock_bindings.CreateBindings());
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info2, callback.callback(), &request2,
- mock_bindings.CreateBindings());
- 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) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.FailAll();
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "error.js");
- net::ProxyInfo proxy_info1;
- net::ProxyInfo proxy_info2;
- std::unique_ptr<net::ProxyResolver::Request> request1;
- std::unique_ptr<net::ProxyResolver::Request> request2;
- net::TestCompletionCallback callback;
- resolver->GetProxyForURL(GURL("http://throw-an-error/"),
- net::NetworkIsolationKey(), &proxy_info1,
- base::BindOnce(&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. Reset deletes Request opject which cancels the request.
- mock_bindings.RunOnError(
- base::BindOnce(&std::unique_ptr<net::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/"),
- net::NetworkIsolationKey(), &proxy_info2,
- callback.callback(), &request2,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ("i-approve-this-message:42",
- ProxyServerToProxyUri(proxy_info2.proxy_server()));
- }
- // This cancellation test exercises a more predictable cancellation codepath --
- // when the request has an outstanding DNS request in flight.
- TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
- base::RunLoop run_loop1;
- HangingProxyHostResolver host_resolver(run_loop1.QuitClosure());
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- net::ProxyInfo proxy_info1;
- net::ProxyInfo proxy_info2;
- std::unique_ptr<net::ProxyResolver::Request> request1;
- std::unique_ptr<net::ProxyResolver::Request> request2;
- resolver->GetProxyForURL(GURL("http://foo/req1"), net::NetworkIsolationKey(),
- &proxy_info1, base::BindOnce(&CrashCallback),
- &request1, mock_bindings.CreateBindings());
- run_loop1.Run();
- base::RunLoop run_loop2;
- host_resolver.set_hang_callback(run_loop2.QuitClosure());
- resolver->GetProxyForURL(GURL("http://foo/req2"), net::NetworkIsolationKey(),
- &proxy_info2, base::BindOnce(&CrashCallback),
- &request2, mock_bindings.CreateBindings());
- run_loop2.Run();
- request1.reset();
- request2.reset();
- EXPECT_EQ(2, host_resolver.num_cancelled_requests());
- // After leaving this scope, the net::ProxyResolver is destroyed.
- // This should not cause any problems, as the outstanding work
- // should have been cancelled.
- }
- void CancelRequestAndPause(
- std::unique_ptr<net::ProxyResolver::Request>* request,
- base::RunLoop* run_loop) {
- 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::Milliseconds(30));
- run_loop->Quit();
- }
- // 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) {
- HangingProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> request;
- base::RunLoop run_loop;
- host_resolver.set_hang_callback(
- base::BindRepeating(&CancelRequestAndPause, &request, &run_loop));
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, base::BindOnce(&CrashCallback),
- &request, mock_bindings.CreateBindings());
- run_loop.Run();
- }
- // Cancel the request while there is a pending DNS request, however before
- // the request is sent to the host resolver.
- TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "dns.js");
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> request;
- resolver->GetProxyForURL(GURL("http://foo/"), net::NetworkIsolationKey(),
- &proxy_info, base::BindOnce(&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::Milliseconds(10));
- request.reset();
- EXPECT_EQ(0u, host_resolver.num_resolve());
- }
- TEST_F(ProxyResolverV8TracingTest,
- CancelCreateResolverWhileOutstandingBlockingDns) {
- base::RunLoop run_loop;
- HangingProxyHostResolver host_resolver(run_loop.QuitClosure());
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8TracingFactory> factory(
- ProxyResolverV8TracingFactory::Create());
- std::unique_ptr<ProxyResolverV8Tracing> resolver;
- std::unique_ptr<net::ProxyResolverFactory::Request> request;
- factory->CreateProxyResolverV8Tracing(
- LoadScriptData("dns_during_init.js"), mock_bindings.CreateBindings(),
- &resolver, base::BindOnce(&CrashCallback), &request);
- run_loop.Run();
- request.reset();
- EXPECT_EQ(1, host_resolver.num_cancelled_requests());
- }
- TEST_F(ProxyResolverV8TracingTest, DeleteFactoryWhileOutstandingBlockingDns) {
- base::RunLoop run_loop;
- HangingProxyHostResolver host_resolver(run_loop.QuitClosure());
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8Tracing> resolver;
- std::unique_ptr<net::ProxyResolverFactory::Request> request;
- {
- std::unique_ptr<ProxyResolverV8TracingFactory> factory(
- ProxyResolverV8TracingFactory::Create());
- factory->CreateProxyResolverV8Tracing(
- LoadScriptData("dns_during_init.js"), mock_bindings.CreateBindings(),
- &resolver, base::BindOnce(&CrashCallback), &request);
- run_loop.Run();
- }
- EXPECT_EQ(1, host_resolver.num_cancelled_requests());
- }
- TEST_F(ProxyResolverV8TracingTest, ErrorLoadingScript) {
- HangingProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- std::unique_ptr<ProxyResolverV8TracingFactory> factory(
- ProxyResolverV8TracingFactory::Create());
- std::unique_ptr<ProxyResolverV8Tracing> resolver;
- std::unique_ptr<net::ProxyResolverFactory::Request> request;
- net::TestCompletionCallback callback;
- factory->CreateProxyResolverV8Tracing(
- LoadScriptData("error_on_load.js"), mock_bindings.CreateBindings(),
- &resolver, callback.callback(), &request);
- EXPECT_THAT(callback.WaitForResult(), IsError(net::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(ProxyResolverV8TracingTest, Terminate) {
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(182, 111, 0, 222)});
- host_resolver.SetResult(
- "host2", net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
- net::NetworkIsolationKey(), {net::IPAddress(111, 33, 44, 55)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "terminate.js");
- net::TestCompletionCallback callback;
- net::ProxyInfo proxy_info;
- std::unique_ptr<net::ProxyResolver::Request> req;
- resolver->GetProxyForURL(
- GURL("http://foopy/req1"), net::NetworkIsolationKey(), &proxy_info,
- 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", ProxyServerToProxyUri(proxy_info.proxy_server()));
- // No errors or alerts.
- EXPECT_TRUE(mock_bindings.GetErrors().empty());
- EXPECT_TRUE(mock_bindings.GetAlerts().empty());
- }
- // Tests that multiple instances of ProxyResolverV8Tracing can coexist and run
- // correctly at the same time. This is relevant because at the moment (time
- // this test was written) each ProxyResolverV8Tracing creates its own thread to
- // run V8 on, however each thread is operating on the same v8::Isolate.
- TEST_F(ProxyResolverV8TracingTest, MultipleResolvers) {
- // ------------------------
- // Setup resolver0
- // ------------------------
- MockProxyHostResolver host_resolver0;
- MockBindings mock_bindings0(&host_resolver0);
- host_resolver0.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS,
- net::NetworkIsolationKey(), {net::IPAddress(122, 133, 144, 155)});
- host_resolver0.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS_EX,
- net::NetworkIsolationKey(), {net::IPAddress(133, 122, 100, 200)});
- host_resolver0.SetError("", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey());
- host_resolver0.SetResult("host1", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 44)});
- net::IPAddress v6_local;
- ASSERT_TRUE(v6_local.AssignFromIPLiteral("::1"));
- host_resolver0.SetResult(
- "host1", net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
- net::NetworkIsolationKey(), {v6_local, net::IPAddress(192, 168, 1, 1)});
- host_resolver0.SetError("host2", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey());
- host_resolver0.SetResult("host3", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 33)});
- host_resolver0.SetError("host6",
- net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
- net::NetworkIsolationKey());
- std::unique_ptr<ProxyResolverV8Tracing> resolver0 =
- CreateResolver(mock_bindings0.CreateBindings(), "dns.js");
- // ------------------------
- // Setup resolver1
- // ------------------------
- std::unique_ptr<ProxyResolverV8Tracing> resolver1 =
- CreateResolver(mock_bindings0.CreateBindings(), "dns.js");
- // ------------------------
- // Setup resolver2
- // ------------------------
- std::unique_ptr<ProxyResolverV8Tracing> resolver2 =
- CreateResolver(mock_bindings0.CreateBindings(), "simple.js");
- // ------------------------
- // Setup resolver3
- // ------------------------
- MockProxyHostResolver host_resolver3;
- MockBindings mock_bindings3(&host_resolver3);
- host_resolver3.SetResult("foo", net::ProxyResolveDnsOperation::DNS_RESOLVE,
- net::NetworkIsolationKey(),
- {net::IPAddress(166, 155, 144, 33)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver3 =
- CreateResolver(mock_bindings3.CreateBindings(), "simple_dns.js");
- // ------------------------
- // Queue up work for each resolver (which will be running in parallel).
- // ------------------------
- ProxyResolverV8Tracing* resolver[] = {
- resolver0.get(),
- resolver1.get(),
- resolver2.get(),
- resolver3.get(),
- };
- const size_t kNumResolvers = std::size(resolver);
- const size_t kNumIterations = 20;
- const size_t kNumResults = kNumResolvers * kNumIterations;
- net::TestCompletionCallback callback[kNumResults];
- net::ProxyInfo proxy_info[kNumResults];
- std::unique_ptr<net::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/"), net::NetworkIsolationKey(), &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')
- "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')
- ".test:99";
- for (size_t i = 0; i < kNumResults; ++i) {
- size_t resolver_i = i % kNumResolvers;
- EXPECT_THAT(callback[i].WaitForResult(), IsOk());
- std::string proxy_uri = ProxyServerToProxyUri(proxy_info[i].proxy_server());
- 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.test:",
- proxy_uri.substr(0, proxy_uri.find(':') + 1));
- } else {
- NOTREACHED();
- }
- }
- }
- // Make sure that NetworkIsolationKeys passed to the ProxyResolverV8Tracing are
- // passed to the ProxyHostResolver. Does this by making a MockProxyHostResolver
- // return different results for the same host based on what
- // net::NetworkIsolationKey is used, and then using a PAC script that returns
- // the IP address a hostname resolves to as a proxy using the two different
- // NetworkIsolationKeys, checking the results.
- TEST_F(ProxyResolverV8TracingTest, NetworkIsolationKey) {
- const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
- const net::NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
- const net::IPAddress kIPAddress1(1, 2, 3, 4);
- const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
- const net::NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
- const net::IPAddress kIPAddress2(5, 6, 7, 8);
- const char kHost[] = "host.test";
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult(kHost, net::ProxyResolveDnsOperation::DNS_RESOLVE,
- kNetworkIsolationKey1, {kIPAddress1});
- host_resolver.SetResult(kHost, net::ProxyResolveDnsOperation::DNS_RESOLVE,
- kNetworkIsolationKey2, {kIPAddress2});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "simple_dns.js");
- net::TestCompletionCallback callback;
- std::unique_ptr<net::ProxyResolver::Request> req;
- net::ProxyInfo proxy_info1;
- resolver->GetProxyForURL(GURL("https://host.test/"), kNetworkIsolationKey1,
- &proxy_info1, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ(2u, host_resolver.num_resolve());
- EXPECT_EQ(kIPAddress1.ToString() + ".test",
- proxy_info1.proxy_server().host_port_pair().host());
- net::ProxyInfo proxy_info2;
- resolver->GetProxyForURL(GURL("https://host.test/"), kNetworkIsolationKey2,
- &proxy_info2, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ(4u, host_resolver.num_resolve());
- EXPECT_EQ(kIPAddress2.ToString() + ".test",
- proxy_info2.proxy_server().host_port_pair().host());
- }
- // Make sure that net::NetworkIsolationKey is not passed to the
- // ProxyHostResolver when looking up either myIpAddress() or myIpAddressEx().
- // This allows their values to be cached across NetworkIsolationKeys. This test
- // works by having the ProxyHostResolver return different results based on the
- // net::NetworkIsolationKey used, and then running a PAC script that returns a
- // result containing the IP address contained by both values, checking the
- // resulting value.
- TEST_F(ProxyResolverV8TracingTest, MyIPAddressWithNetworkIsolationKey) {
- const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.test/"));
- const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
- MockProxyHostResolver host_resolver;
- MockBindings mock_bindings(&host_resolver);
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS,
- net::NetworkIsolationKey(), {net::IPAddress(1, 2, 3, 4)});
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS_EX,
- net::NetworkIsolationKey(), {net::IPAddress(5, 6, 7, 8)});
- host_resolver.SetResult(net::GetHostName(),
- net::ProxyResolveDnsOperation::MY_IP_ADDRESS,
- kNetworkIsolationKey, {net::IPAddress(9, 9, 9, 9)});
- host_resolver.SetResult(
- net::GetHostName(), net::ProxyResolveDnsOperation::MY_IP_ADDRESS_EX,
- kNetworkIsolationKey, {net::IPAddress(10, 10, 10, 10)});
- std::unique_ptr<ProxyResolverV8Tracing> resolver =
- CreateResolver(mock_bindings.CreateBindings(), "my_ip_address.js");
- net::TestCompletionCallback callback;
- std::unique_ptr<net::ProxyResolver::Request> req;
- net::ProxyInfo proxy_info;
- resolver->GetProxyForURL(GURL("https://host.test/"), kNetworkIsolationKey,
- &proxy_info, callback.callback(), &req,
- mock_bindings.CreateBindings());
- EXPECT_THAT(callback.WaitForResult(), IsOk());
- EXPECT_EQ(2u, host_resolver.num_resolve());
- EXPECT_EQ("1.2.3.4-5.6.7.8.test",
- proxy_info.proxy_server().host_port_pair().host());
- }
- } // namespace
- } // namespace proxy_resolver
|