proxy_resolver_factory_mojo_unittest.cc 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969
  1. // Copyright 2015 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. #include "services/network/proxy_resolver_factory_mojo.h"
  5. #include <list>
  6. #include <map>
  7. #include <memory>
  8. #include <string>
  9. #include <tuple>
  10. #include <utility>
  11. #include <vector>
  12. #include "base/bind.h"
  13. #include "base/callback_helpers.h"
  14. #include "base/containers/queue.h"
  15. #include "base/memory/raw_ptr.h"
  16. #include "base/run_loop.h"
  17. #include "base/test/task_environment.h"
  18. #include "base/values.h"
  19. #include "mojo/public/cpp/bindings/receiver.h"
  20. #include "mojo/public/cpp/bindings/remote.h"
  21. #include "net/base/load_states.h"
  22. #include "net/base/net_errors.h"
  23. #include "net/base/network_isolation_key.h"
  24. #include "net/base/test_completion_callback.h"
  25. #include "net/dns/mock_host_resolver.h"
  26. #include "net/log/net_log.h"
  27. #include "net/log/net_log_event_type.h"
  28. #include "net/log/net_log_with_source.h"
  29. #include "net/log/test_net_log.h"
  30. #include "net/log/test_net_log_util.h"
  31. #include "net/proxy_resolution/pac_file_data.h"
  32. #include "net/proxy_resolution/proxy_info.h"
  33. #include "net/proxy_resolution/proxy_resolve_dns_operation.h"
  34. #include "net/proxy_resolution/proxy_resolver.h"
  35. #include "net/proxy_resolution/proxy_resolver_error_observer.h"
  36. #include "net/proxy_resolution/proxy_resolver_factory.h"
  37. #include "net/test/event_waiter.h"
  38. #include "net/test/gtest_util.h"
  39. #include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
  40. #include "testing/gmock/include/gmock/gmock.h"
  41. #include "testing/gtest/include/gtest/gtest.h"
  42. #include "url/gurl.h"
  43. #include "url/origin.h"
  44. using net::test::IsError;
  45. using net::test::IsOk;
  46. namespace network {
  47. namespace {
  48. const char kScriptData[] = "FooBarBaz";
  49. const char kExampleUrl[] = "http://www.example.com";
  50. struct CreateProxyResolverAction {
  51. enum Action {
  52. COMPLETE,
  53. DROP_CLIENT,
  54. DROP_RESOLVER,
  55. DROP_BOTH,
  56. WAIT_FOR_CLIENT_DISCONNECT,
  57. MAKE_DNS_REQUEST,
  58. };
  59. static CreateProxyResolverAction ReturnResult(
  60. const std::string& expected_pac_script,
  61. net::Error error) {
  62. CreateProxyResolverAction result;
  63. result.expected_pac_script = expected_pac_script;
  64. result.error = error;
  65. return result;
  66. }
  67. static CreateProxyResolverAction DropClient(
  68. const std::string& expected_pac_script) {
  69. CreateProxyResolverAction result;
  70. result.expected_pac_script = expected_pac_script;
  71. result.action = DROP_CLIENT;
  72. return result;
  73. }
  74. static CreateProxyResolverAction DropResolver(
  75. const std::string& expected_pac_script) {
  76. CreateProxyResolverAction result;
  77. result.expected_pac_script = expected_pac_script;
  78. result.action = DROP_RESOLVER;
  79. return result;
  80. }
  81. static CreateProxyResolverAction DropBoth(
  82. const std::string& expected_pac_script) {
  83. CreateProxyResolverAction result;
  84. result.expected_pac_script = expected_pac_script;
  85. result.action = DROP_BOTH;
  86. return result;
  87. }
  88. static CreateProxyResolverAction WaitForClientDisconnect(
  89. const std::string& expected_pac_script) {
  90. CreateProxyResolverAction result;
  91. result.expected_pac_script = expected_pac_script;
  92. result.action = WAIT_FOR_CLIENT_DISCONNECT;
  93. return result;
  94. }
  95. static CreateProxyResolverAction MakeDnsRequest(
  96. const std::string& expected_pac_script) {
  97. CreateProxyResolverAction result;
  98. result.expected_pac_script = expected_pac_script;
  99. result.action = MAKE_DNS_REQUEST;
  100. return result;
  101. }
  102. std::string expected_pac_script;
  103. Action action = COMPLETE;
  104. net::Error error = net::OK;
  105. };
  106. struct GetProxyForUrlAction {
  107. enum Action {
  108. COMPLETE,
  109. // Drop the request by closing the reply channel.
  110. DROP,
  111. // Disconnect the service.
  112. DISCONNECT,
  113. // Wait for the client pipe to be disconnected.
  114. WAIT_FOR_CLIENT_DISCONNECT,
  115. // Make a DNS request.
  116. MAKE_DNS_REQUEST,
  117. };
  118. GetProxyForUrlAction() {}
  119. GetProxyForUrlAction(const GetProxyForUrlAction& other) = default;
  120. static GetProxyForUrlAction ReturnError(const GURL& url, net::Error error) {
  121. GetProxyForUrlAction result;
  122. result.expected_url = url;
  123. result.error = error;
  124. return result;
  125. }
  126. static GetProxyForUrlAction ReturnServers(const GURL& url,
  127. const net::ProxyInfo& proxy_info) {
  128. GetProxyForUrlAction result;
  129. result.expected_url = url;
  130. result.proxy_info = proxy_info;
  131. return result;
  132. }
  133. static GetProxyForUrlAction DropRequest(const GURL& url) {
  134. GetProxyForUrlAction result;
  135. result.expected_url = url;
  136. result.action = DROP;
  137. return result;
  138. }
  139. static GetProxyForUrlAction Disconnect(const GURL& url) {
  140. GetProxyForUrlAction result;
  141. result.expected_url = url;
  142. result.action = DISCONNECT;
  143. return result;
  144. }
  145. static GetProxyForUrlAction WaitForClientDisconnect(const GURL& url) {
  146. GetProxyForUrlAction result;
  147. result.expected_url = url;
  148. result.action = WAIT_FOR_CLIENT_DISCONNECT;
  149. return result;
  150. }
  151. static GetProxyForUrlAction MakeDnsRequest(const GURL& url) {
  152. GetProxyForUrlAction result;
  153. result.expected_url = url;
  154. result.action = MAKE_DNS_REQUEST;
  155. return result;
  156. }
  157. Action action = COMPLETE;
  158. net::Error error = net::OK;
  159. net::ProxyInfo proxy_info;
  160. GURL expected_url;
  161. };
  162. class MockMojoProxyResolver : public proxy_resolver::mojom::ProxyResolver {
  163. public:
  164. MockMojoProxyResolver();
  165. ~MockMojoProxyResolver() override;
  166. void AddGetProxyAction(GetProxyForUrlAction action);
  167. void WaitForNextRequest();
  168. void ClearBlockedClients();
  169. void AddConnection(
  170. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver);
  171. private:
  172. // Overridden from proxy_resolver::mojom::ProxyResolver:
  173. void GetProxyForUrl(
  174. const GURL& url,
  175. const net::NetworkIsolationKey& network_isolation_key,
  176. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverRequestClient>
  177. pending_client) override;
  178. void WakeWaiter();
  179. std::string pac_script_data_;
  180. base::queue<GetProxyForUrlAction> get_proxy_actions_;
  181. base::OnceClosure quit_closure_;
  182. std::vector<mojo::Remote<proxy_resolver::mojom::ProxyResolverRequestClient>>
  183. blocked_clients_;
  184. mojo::Receiver<proxy_resolver::mojom::ProxyResolver> receiver_{this};
  185. };
  186. MockMojoProxyResolver::~MockMojoProxyResolver() {
  187. EXPECT_TRUE(get_proxy_actions_.empty())
  188. << "Actions remaining: " << get_proxy_actions_.size();
  189. }
  190. MockMojoProxyResolver::MockMojoProxyResolver() = default;
  191. void MockMojoProxyResolver::AddGetProxyAction(GetProxyForUrlAction action) {
  192. get_proxy_actions_.push(action);
  193. }
  194. void MockMojoProxyResolver::WaitForNextRequest() {
  195. base::RunLoop run_loop;
  196. quit_closure_ = run_loop.QuitClosure();
  197. run_loop.Run();
  198. }
  199. void MockMojoProxyResolver::WakeWaiter() {
  200. if (!quit_closure_.is_null())
  201. std::move(quit_closure_).Run();
  202. }
  203. void MockMojoProxyResolver::ClearBlockedClients() {
  204. blocked_clients_.clear();
  205. }
  206. void MockMojoProxyResolver::AddConnection(
  207. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver) {
  208. receiver_.reset();
  209. receiver_.Bind(std::move(receiver));
  210. }
  211. void MockMojoProxyResolver::GetProxyForUrl(
  212. const GURL& url,
  213. const net::NetworkIsolationKey& network_isolation_key,
  214. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverRequestClient>
  215. pending_client) {
  216. ASSERT_FALSE(get_proxy_actions_.empty());
  217. GetProxyForUrlAction action = get_proxy_actions_.front();
  218. get_proxy_actions_.pop();
  219. EXPECT_EQ(action.expected_url, url);
  220. mojo::Remote<proxy_resolver::mojom::ProxyResolverRequestClient> client(
  221. std::move(pending_client));
  222. client->Alert(url.spec());
  223. client->OnError(12345, url.spec());
  224. switch (action.action) {
  225. case GetProxyForUrlAction::COMPLETE: {
  226. client->ReportResult(action.error, action.proxy_info);
  227. break;
  228. }
  229. case GetProxyForUrlAction::DROP: {
  230. client.reset();
  231. break;
  232. }
  233. case GetProxyForUrlAction::DISCONNECT: {
  234. receiver_.reset();
  235. break;
  236. }
  237. case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT: {
  238. base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
  239. client.set_disconnect_handler(run_loop.QuitClosure());
  240. run_loop.Run();
  241. ASSERT_FALSE(client.is_connected());
  242. break;
  243. }
  244. case GetProxyForUrlAction::MAKE_DNS_REQUEST: {
  245. mojo::PendingRemote<proxy_resolver::mojom::HostResolverRequestClient>
  246. dns_client;
  247. std::ignore = dns_client.InitWithNewPipeAndPassReceiver();
  248. client->ResolveDns(url.host(),
  249. net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
  250. network_isolation_key, std::move(dns_client));
  251. blocked_clients_.push_back(std::move(client));
  252. break;
  253. }
  254. }
  255. WakeWaiter();
  256. }
  257. class Request {
  258. public:
  259. Request(net::ProxyResolver* resolver,
  260. const GURL& url,
  261. const net::NetworkIsolationKey& network_isolation_key);
  262. int Resolve();
  263. void Cancel();
  264. int WaitForResult();
  265. const net::ProxyInfo& results() const { return results_; }
  266. net::LoadState load_state() { return request_->GetLoadState(); }
  267. net::NetLogWithSource& net_log_with_source() { return net_log_with_source_; }
  268. const net::TestCompletionCallback& callback() const { return callback_; }
  269. private:
  270. raw_ptr<net::ProxyResolver> resolver_;
  271. const GURL url_;
  272. const net::NetworkIsolationKey network_isolation_key_;
  273. net::ProxyInfo results_;
  274. std::unique_ptr<net::ProxyResolver::Request> request_;
  275. int error_;
  276. net::TestCompletionCallback callback_;
  277. net::NetLogWithSource net_log_with_source_{
  278. net::NetLogWithSource::Make(net::NetLogSourceType::NONE)};
  279. };
  280. Request::Request(net::ProxyResolver* resolver,
  281. const GURL& url,
  282. const net::NetworkIsolationKey& network_isolation_key)
  283. : resolver_(resolver),
  284. url_(url),
  285. network_isolation_key_(network_isolation_key),
  286. error_(0) {}
  287. int Request::Resolve() {
  288. error_ = resolver_->GetProxyForURL(url_, network_isolation_key_, &results_,
  289. callback_.callback(), &request_,
  290. net_log_with_source_);
  291. return error_;
  292. }
  293. void Request::Cancel() {
  294. request_.reset();
  295. }
  296. int Request::WaitForResult() {
  297. error_ = callback_.WaitForResult();
  298. return error_;
  299. }
  300. class MockMojoProxyResolverFactory
  301. : public proxy_resolver::mojom::ProxyResolverFactory {
  302. public:
  303. MockMojoProxyResolverFactory(
  304. MockMojoProxyResolver* resolver,
  305. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolverFactory>
  306. receiver);
  307. ~MockMojoProxyResolverFactory() override;
  308. void AddCreateProxyResolverAction(CreateProxyResolverAction action);
  309. void WaitForNextRequest();
  310. void ClearBlockedClients();
  311. void RespondToBlockedClientsWithResult(net::Error error);
  312. private:
  313. // Overridden from proxy_resolver::mojom::ProxyResolver:
  314. void CreateResolver(
  315. const std::string& pac_url,
  316. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver,
  317. mojo::PendingRemote<
  318. proxy_resolver::mojom::ProxyResolverFactoryRequestClient>
  319. pending_client) override;
  320. void WakeWaiter();
  321. raw_ptr<MockMojoProxyResolver> resolver_;
  322. base::queue<CreateProxyResolverAction> create_resolver_actions_;
  323. base::OnceClosure quit_closure_;
  324. std::vector<
  325. mojo::Remote<proxy_resolver::mojom::ProxyResolverFactoryRequestClient>>
  326. blocked_clients_;
  327. std::vector<mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver>>
  328. blocked_resolver_receivers_;
  329. mojo::Receiver<proxy_resolver::mojom::ProxyResolverFactory> receiver_;
  330. };
  331. MockMojoProxyResolverFactory::MockMojoProxyResolverFactory(
  332. MockMojoProxyResolver* resolver,
  333. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolverFactory> receiver)
  334. : resolver_(resolver), receiver_(this, std::move(receiver)) {}
  335. MockMojoProxyResolverFactory::~MockMojoProxyResolverFactory() {
  336. EXPECT_TRUE(create_resolver_actions_.empty())
  337. << "Actions remaining: " << create_resolver_actions_.size();
  338. }
  339. void MockMojoProxyResolverFactory::AddCreateProxyResolverAction(
  340. CreateProxyResolverAction action) {
  341. create_resolver_actions_.push(action);
  342. }
  343. void MockMojoProxyResolverFactory::WaitForNextRequest() {
  344. base::RunLoop run_loop;
  345. quit_closure_ = run_loop.QuitClosure();
  346. run_loop.Run();
  347. }
  348. void MockMojoProxyResolverFactory::WakeWaiter() {
  349. if (!quit_closure_.is_null())
  350. std::move(quit_closure_).Run();
  351. }
  352. void MockMojoProxyResolverFactory::ClearBlockedClients() {
  353. blocked_clients_.clear();
  354. }
  355. void MockMojoProxyResolverFactory::RespondToBlockedClientsWithResult(
  356. net::Error error) {
  357. for (const auto& client : blocked_clients_) {
  358. client->ReportResult(error);
  359. }
  360. }
  361. void MockMojoProxyResolverFactory::CreateResolver(
  362. const std::string& pac_script,
  363. mojo::PendingReceiver<proxy_resolver::mojom::ProxyResolver> receiver,
  364. mojo::PendingRemote<
  365. proxy_resolver::mojom::ProxyResolverFactoryRequestClient>
  366. pending_client) {
  367. ASSERT_FALSE(create_resolver_actions_.empty());
  368. CreateProxyResolverAction action = create_resolver_actions_.front();
  369. create_resolver_actions_.pop();
  370. EXPECT_EQ(action.expected_pac_script, pac_script);
  371. mojo::Remote<proxy_resolver::mojom::ProxyResolverFactoryRequestClient> client(
  372. std::move(pending_client));
  373. client->Alert(pac_script);
  374. client->OnError(12345, pac_script);
  375. switch (action.action) {
  376. case CreateProxyResolverAction::COMPLETE: {
  377. if (action.error == net::OK)
  378. resolver_->AddConnection(std::move(receiver));
  379. client->ReportResult(action.error);
  380. break;
  381. }
  382. case CreateProxyResolverAction::DROP_CLIENT: {
  383. // Save |receiver| so its pipe isn't closed.
  384. blocked_resolver_receivers_.push_back(std::move(receiver));
  385. break;
  386. }
  387. case CreateProxyResolverAction::DROP_RESOLVER: {
  388. // Save |client| so its pipe isn't closed.
  389. blocked_clients_.push_back(std::move(client));
  390. break;
  391. }
  392. case CreateProxyResolverAction::DROP_BOTH: {
  393. // Both |receiver| and |client| will be closed.
  394. break;
  395. }
  396. case CreateProxyResolverAction::WAIT_FOR_CLIENT_DISCONNECT: {
  397. base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
  398. client.set_disconnect_handler(run_loop.QuitClosure());
  399. run_loop.Run();
  400. ASSERT_FALSE(client.is_connected());
  401. break;
  402. }
  403. case CreateProxyResolverAction::MAKE_DNS_REQUEST: {
  404. mojo::PendingRemote<proxy_resolver::mojom::HostResolverRequestClient>
  405. dns_client;
  406. std::ignore = dns_client.InitWithNewPipeAndPassReceiver();
  407. client->ResolveDns(pac_script,
  408. net::ProxyResolveDnsOperation::DNS_RESOLVE_EX,
  409. net::NetworkIsolationKey(), std::move(dns_client));
  410. blocked_clients_.push_back(std::move(client));
  411. break;
  412. }
  413. }
  414. WakeWaiter();
  415. }
  416. void DeleteResolverFactoryRequestCallback(
  417. std::unique_ptr<net::ProxyResolverFactory::Request>* request,
  418. net::CompletionOnceCallback callback,
  419. int result) {
  420. ASSERT_TRUE(request);
  421. EXPECT_TRUE(request->get());
  422. request->reset();
  423. std::move(callback).Run(result);
  424. }
  425. void CheckCapturedNetLogEntries(const std::string& expected_string,
  426. const std::vector<net::NetLogEntry>& entries) {
  427. ASSERT_EQ(2u, entries.size());
  428. EXPECT_EQ(net::NetLogEventType::PAC_JAVASCRIPT_ALERT, entries[0].type);
  429. EXPECT_EQ(expected_string,
  430. net::GetStringValueFromParams(entries[0], "message"));
  431. ASSERT_FALSE(entries[0].params.FindKey("line_number"));
  432. EXPECT_EQ(net::NetLogEventType::PAC_JAVASCRIPT_ERROR, entries[1].type);
  433. EXPECT_EQ(expected_string,
  434. net::GetStringValueFromParams(entries[1], "message"));
  435. EXPECT_EQ(12345, net::GetIntegerValueFromParams(entries[1], "line_number"));
  436. }
  437. } // namespace
  438. class ProxyResolverFactoryMojoTest : public testing::Test {
  439. public:
  440. void SetUp() override {
  441. mojo::PendingRemote<proxy_resolver::mojom::ProxyResolverFactory>
  442. factory_remote;
  443. mock_proxy_resolver_factory_ =
  444. std::make_unique<MockMojoProxyResolverFactory>(
  445. &mock_proxy_resolver_,
  446. factory_remote.InitWithNewPipeAndPassReceiver());
  447. proxy_resolver_factory_mojo_ = std::make_unique<ProxyResolverFactoryMojo>(
  448. std::move(factory_remote), &host_resolver_, base::NullCallback(),
  449. net::NetLog::Get());
  450. }
  451. std::unique_ptr<Request> MakeRequest(
  452. const GURL& url,
  453. const net::NetworkIsolationKey& network_isolation_key =
  454. net::NetworkIsolationKey()) {
  455. return std::make_unique<Request>(proxy_resolver_mojo_.get(), url,
  456. network_isolation_key);
  457. }
  458. net::ProxyInfo ProxyServersFromPacString(const std::string& pac_string) {
  459. net::ProxyInfo proxy_info;
  460. proxy_info.UsePacString(pac_string);
  461. return proxy_info;
  462. }
  463. void CreateProxyResolver() {
  464. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  465. CreateProxyResolverAction::ReturnResult(kScriptData, net::OK));
  466. net::TestCompletionCallback callback;
  467. scoped_refptr<net::PacFileData> pac_script(
  468. net::PacFileData::FromUTF8(kScriptData));
  469. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  470. ASSERT_EQ(
  471. net::OK,
  472. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  473. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  474. EXPECT_TRUE(request);
  475. ASSERT_TRUE(proxy_resolver_mojo_);
  476. }
  477. void DeleteProxyResolverCallback(net::CompletionOnceCallback callback,
  478. int result) {
  479. proxy_resolver_mojo_.reset();
  480. std::move(callback).Run(result);
  481. }
  482. base::test::TaskEnvironment task_environment_;
  483. net::HangingHostResolver host_resolver_;
  484. net::RecordingNetLogObserver net_log_observer_;
  485. std::unique_ptr<MockMojoProxyResolverFactory> mock_proxy_resolver_factory_;
  486. std::unique_ptr<net::ProxyResolverFactory> proxy_resolver_factory_mojo_;
  487. MockMojoProxyResolver mock_proxy_resolver_;
  488. std::unique_ptr<net::ProxyResolver> proxy_resolver_mojo_;
  489. };
  490. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver) {
  491. CreateProxyResolver();
  492. CheckCapturedNetLogEntries(kScriptData, net_log_observer_.GetEntries());
  493. }
  494. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Empty) {
  495. net::TestCompletionCallback callback;
  496. scoped_refptr<net::PacFileData> pac_script(net::PacFileData::FromUTF8(""));
  497. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  498. EXPECT_EQ(
  499. net::ERR_PAC_SCRIPT_FAILED,
  500. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  501. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  502. EXPECT_FALSE(request);
  503. }
  504. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Url) {
  505. net::TestCompletionCallback callback;
  506. scoped_refptr<net::PacFileData> pac_script(
  507. net::PacFileData::FromURL(GURL(kExampleUrl)));
  508. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  509. EXPECT_EQ(
  510. net::ERR_PAC_SCRIPT_FAILED,
  511. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  512. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  513. EXPECT_FALSE(request);
  514. }
  515. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Failed) {
  516. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  517. CreateProxyResolverAction::ReturnResult(
  518. kScriptData, net::ERR_HTTP_RESPONSE_CODE_FAILURE));
  519. net::TestCompletionCallback callback;
  520. scoped_refptr<net::PacFileData> pac_script(
  521. net::PacFileData::FromUTF8(kScriptData));
  522. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  523. EXPECT_EQ(
  524. net::ERR_HTTP_RESPONSE_CODE_FAILURE,
  525. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  526. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  527. EXPECT_TRUE(request);
  528. // A second attempt succeeds.
  529. CreateProxyResolver();
  530. }
  531. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_BothDisconnected) {
  532. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  533. CreateProxyResolverAction::DropBoth(kScriptData));
  534. scoped_refptr<net::PacFileData> pac_script(
  535. net::PacFileData::FromUTF8(kScriptData));
  536. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  537. net::TestCompletionCallback callback;
  538. EXPECT_EQ(
  539. net::ERR_PAC_SCRIPT_TERMINATED,
  540. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  541. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  542. EXPECT_TRUE(request);
  543. }
  544. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_ClientDisconnected) {
  545. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  546. CreateProxyResolverAction::DropClient(kScriptData));
  547. scoped_refptr<net::PacFileData> pac_script(
  548. net::PacFileData::FromUTF8(kScriptData));
  549. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  550. net::TestCompletionCallback callback;
  551. EXPECT_EQ(
  552. net::ERR_PAC_SCRIPT_TERMINATED,
  553. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  554. pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
  555. EXPECT_TRUE(request);
  556. }
  557. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_ResolverDisconnected) {
  558. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  559. CreateProxyResolverAction::DropResolver(kScriptData));
  560. scoped_refptr<net::PacFileData> pac_script(
  561. net::PacFileData::FromUTF8(kScriptData));
  562. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  563. // When the ResolverRequest pipe is dropped, the ProxyResolverFactory should
  564. // still wait to get an error from the client pipe.
  565. net::TestCompletionCallback callback;
  566. EXPECT_EQ(
  567. net::ERR_IO_PENDING,
  568. proxy_resolver_factory_mojo_->CreateProxyResolver(
  569. pac_script, &proxy_resolver_mojo_, callback.callback(), &request));
  570. EXPECT_TRUE(request);
  571. base::RunLoop().RunUntilIdle();
  572. EXPECT_FALSE(callback.have_result());
  573. mock_proxy_resolver_factory_->RespondToBlockedClientsWithResult(
  574. net::ERR_PAC_SCRIPT_FAILED);
  575. EXPECT_EQ(net::ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
  576. }
  577. // The resolver pipe is dropped, but the client is told the request succeeded
  578. // (This could happen if a proxy resolver is created successfully, but then the
  579. // proxy crashes before the client reads the success message).
  580. TEST_F(ProxyResolverFactoryMojoTest,
  581. CreateProxyResolver_ResolverDisconnectedButClientSucceeded) {
  582. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  583. CreateProxyResolverAction::DropResolver(kScriptData));
  584. scoped_refptr<net::PacFileData> pac_script(
  585. net::PacFileData::FromUTF8(kScriptData));
  586. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  587. // When the ResolverRequest pipe is dropped, the ProxyResolverFactory
  588. // shouldn't notice, and should just continue to wait for a response on the
  589. // other pipe.
  590. net::TestCompletionCallback create_callback;
  591. EXPECT_EQ(net::ERR_IO_PENDING,
  592. proxy_resolver_factory_mojo_->CreateProxyResolver(
  593. pac_script, &proxy_resolver_mojo_, create_callback.callback(),
  594. &request));
  595. EXPECT_TRUE(request);
  596. mock_proxy_resolver_factory_->WaitForNextRequest();
  597. base::RunLoop().RunUntilIdle();
  598. EXPECT_FALSE(create_callback.have_result());
  599. // The client pipe reports success!
  600. mock_proxy_resolver_factory_->RespondToBlockedClientsWithResult(net::OK);
  601. EXPECT_EQ(net::OK, create_callback.WaitForResult());
  602. // Proxy resolutions should fail with ERR_PAC_SCRIPT_TERMINATED, however. That
  603. // error should normally cause the ProxyResolutionService to destroy the
  604. // resolver.
  605. net::ProxyInfo results;
  606. std::unique_ptr<net::ProxyResolver::Request> pac_request;
  607. net::TestCompletionCallback delete_callback;
  608. EXPECT_EQ(net::ERR_PAC_SCRIPT_TERMINATED,
  609. delete_callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
  610. GURL(kExampleUrl), net::NetworkIsolationKey(), &results,
  611. base::BindOnce(
  612. &ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
  613. base::Unretained(this), delete_callback.callback()),
  614. &pac_request, net::NetLogWithSource())));
  615. }
  616. TEST_F(ProxyResolverFactoryMojoTest,
  617. CreateProxyResolver_ResolverDisconnected_DeleteRequestInCallback) {
  618. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  619. CreateProxyResolverAction::DropClient(kScriptData));
  620. scoped_refptr<net::PacFileData> pac_script(
  621. net::PacFileData::FromUTF8(kScriptData));
  622. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  623. net::TestCompletionCallback callback;
  624. EXPECT_EQ(
  625. net::ERR_PAC_SCRIPT_TERMINATED,
  626. callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
  627. pac_script, &proxy_resolver_mojo_,
  628. base::BindOnce(&DeleteResolverFactoryRequestCallback, &request,
  629. callback.callback()),
  630. &request)));
  631. }
  632. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_Cancel) {
  633. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  634. CreateProxyResolverAction::WaitForClientDisconnect(kScriptData));
  635. scoped_refptr<net::PacFileData> pac_script(
  636. net::PacFileData::FromUTF8(kScriptData));
  637. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  638. net::TestCompletionCallback callback;
  639. EXPECT_EQ(
  640. net::ERR_IO_PENDING,
  641. proxy_resolver_factory_mojo_->CreateProxyResolver(
  642. pac_script, &proxy_resolver_mojo_, callback.callback(), &request));
  643. ASSERT_TRUE(request);
  644. request.reset();
  645. // The Mojo request is still made.
  646. mock_proxy_resolver_factory_->WaitForNextRequest();
  647. }
  648. TEST_F(ProxyResolverFactoryMojoTest, CreateProxyResolver_DnsRequest) {
  649. mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
  650. CreateProxyResolverAction::MakeDnsRequest(kScriptData));
  651. scoped_refptr<net::PacFileData> pac_script(
  652. net::PacFileData::FromUTF8(kScriptData));
  653. std::unique_ptr<net::ProxyResolverFactory::Request> request;
  654. net::TestCompletionCallback callback;
  655. EXPECT_EQ(
  656. net::ERR_IO_PENDING,
  657. proxy_resolver_factory_mojo_->CreateProxyResolver(
  658. pac_script, &proxy_resolver_mojo_, callback.callback(), &request));
  659. ASSERT_TRUE(request);
  660. base::RunLoop run_loop;
  661. run_loop.RunUntilIdle();
  662. mock_proxy_resolver_factory_->ClearBlockedClients();
  663. callback.WaitForResult();
  664. EXPECT_EQ(1, host_resolver_.num_cancellations());
  665. }
  666. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL) {
  667. const GURL url(kExampleUrl);
  668. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
  669. url, ProxyServersFromPacString("DIRECT")));
  670. CreateProxyResolver();
  671. net_log_observer_.Clear();
  672. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  673. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  674. EXPECT_THAT(request->WaitForResult(), IsOk());
  675. EXPECT_EQ("DIRECT", request->results().ToPacString());
  676. CheckCapturedNetLogEntries(url.spec(),
  677. net_log_observer_.GetEntriesForSource(
  678. request->net_log_with_source().source()));
  679. }
  680. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleResults) {
  681. static const char kPacString[] =
  682. "PROXY foo1:80;DIRECT;SOCKS foo2:1234;"
  683. "SOCKS5 foo3:1080;HTTPS foo4:443;QUIC foo6:8888";
  684. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
  685. GURL(kExampleUrl), ProxyServersFromPacString(kPacString)));
  686. CreateProxyResolver();
  687. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  688. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  689. EXPECT_THAT(request->WaitForResult(), IsOk());
  690. EXPECT_EQ(kPacString, request->results().ToPacString());
  691. }
  692. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Error) {
  693. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnError(
  694. GURL(kExampleUrl), net::ERR_UNEXPECTED));
  695. CreateProxyResolver();
  696. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  697. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  698. EXPECT_THAT(request->WaitForResult(), IsError(net::ERR_UNEXPECTED));
  699. EXPECT_TRUE(request->results().is_empty());
  700. }
  701. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Cancel) {
  702. mock_proxy_resolver_.AddGetProxyAction(
  703. GetProxyForUrlAction::WaitForClientDisconnect(GURL(kExampleUrl)));
  704. CreateProxyResolver();
  705. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  706. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  707. request->Cancel();
  708. EXPECT_FALSE(request->callback().have_result());
  709. // The Mojo request is still made.
  710. mock_proxy_resolver_.WaitForNextRequest();
  711. }
  712. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleRequests) {
  713. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
  714. GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
  715. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
  716. GURL("https://www.chromium.org"),
  717. ProxyServersFromPacString("HTTPS foo:443")));
  718. CreateProxyResolver();
  719. std::unique_ptr<Request> request1(MakeRequest(GURL(kExampleUrl)));
  720. EXPECT_THAT(request1->Resolve(), IsError(net::ERR_IO_PENDING));
  721. std::unique_ptr<Request> request2(
  722. MakeRequest(GURL("https://www.chromium.org")));
  723. EXPECT_THAT(request2->Resolve(), IsError(net::ERR_IO_PENDING));
  724. EXPECT_THAT(request1->WaitForResult(), IsOk());
  725. EXPECT_THAT(request2->WaitForResult(), IsOk());
  726. EXPECT_EQ("DIRECT", request1->results().ToPacString());
  727. EXPECT_EQ("HTTPS foo:443", request2->results().ToPacString());
  728. }
  729. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Disconnect) {
  730. mock_proxy_resolver_.AddGetProxyAction(
  731. GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
  732. CreateProxyResolver();
  733. {
  734. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  735. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  736. EXPECT_THAT(request->WaitForResult(),
  737. IsError(net::ERR_PAC_SCRIPT_TERMINATED));
  738. EXPECT_TRUE(request->results().is_empty());
  739. }
  740. // Run Watcher::OnHandleReady() tasks posted by Watcher::CallOnHandleReady().
  741. base::RunLoop().RunUntilIdle();
  742. {
  743. // Calling GetProxyForURL after a disconnect should fail.
  744. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  745. EXPECT_THAT(request->Resolve(), IsError(net::ERR_PAC_SCRIPT_TERMINATED));
  746. }
  747. }
  748. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_ClientClosed) {
  749. mock_proxy_resolver_.AddGetProxyAction(
  750. GetProxyForUrlAction::DropRequest(GURL(kExampleUrl)));
  751. CreateProxyResolver();
  752. std::unique_ptr<Request> request1(MakeRequest(GURL(kExampleUrl)));
  753. EXPECT_THAT(request1->Resolve(), IsError(net::ERR_IO_PENDING));
  754. EXPECT_THAT(request1->WaitForResult(),
  755. IsError(net::ERR_PAC_SCRIPT_TERMINATED));
  756. }
  757. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DeleteInCallback) {
  758. mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
  759. GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
  760. CreateProxyResolver();
  761. net::ProxyInfo results;
  762. net::TestCompletionCallback callback;
  763. std::unique_ptr<net::ProxyResolver::Request> request;
  764. net::NetLogWithSource net_log;
  765. EXPECT_EQ(net::OK,
  766. callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
  767. GURL(kExampleUrl), net::NetworkIsolationKey(), &results,
  768. base::BindOnce(
  769. &ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
  770. base::Unretained(this), callback.callback()),
  771. &request, net_log)));
  772. }
  773. TEST_F(ProxyResolverFactoryMojoTest,
  774. GetProxyForURL_DeleteInCallbackFromDisconnect) {
  775. mock_proxy_resolver_.AddGetProxyAction(
  776. GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
  777. CreateProxyResolver();
  778. net::ProxyInfo results;
  779. net::TestCompletionCallback callback;
  780. std::unique_ptr<net::ProxyResolver::Request> request;
  781. net::NetLogWithSource net_log;
  782. EXPECT_EQ(net::ERR_PAC_SCRIPT_TERMINATED,
  783. callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
  784. GURL(kExampleUrl), net::NetworkIsolationKey(), &results,
  785. base::BindOnce(
  786. &ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
  787. base::Unretained(this), callback.callback()),
  788. &request, net_log)));
  789. }
  790. TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DnsRequest) {
  791. mock_proxy_resolver_.AddGetProxyAction(
  792. GetProxyForUrlAction::MakeDnsRequest(GURL(kExampleUrl)));
  793. CreateProxyResolver();
  794. std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
  795. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  796. EXPECT_EQ(net::LOAD_STATE_RESOLVING_PROXY_FOR_URL, request->load_state());
  797. base::RunLoop run_loop;
  798. run_loop.RunUntilIdle();
  799. mock_proxy_resolver_.ClearBlockedClients();
  800. request->WaitForResult();
  801. EXPECT_EQ(1, host_resolver_.num_cancellations());
  802. }
  803. TEST_F(ProxyResolverFactoryMojoTest,
  804. GetProxyForURL_DnsRequestWithNetworkIsolationKey) {
  805. const url::Origin kOrigin(url::Origin::Create(GURL("https://origin.test/")));
  806. const net::NetworkIsolationKey kNetworkIsolationKey(kOrigin, kOrigin);
  807. const GURL kUrl(kExampleUrl);
  808. mock_proxy_resolver_.AddGetProxyAction(
  809. GetProxyForUrlAction::MakeDnsRequest(kUrl));
  810. CreateProxyResolver();
  811. std::unique_ptr<Request> request(MakeRequest(kUrl, kNetworkIsolationKey));
  812. EXPECT_THAT(request->Resolve(), IsError(net::ERR_IO_PENDING));
  813. EXPECT_EQ(net::LOAD_STATE_RESOLVING_PROXY_FOR_URL, request->load_state());
  814. base::RunLoop run_loop;
  815. run_loop.RunUntilIdle();
  816. EXPECT_EQ(kUrl.host(), host_resolver_.last_host().host());
  817. EXPECT_EQ(kNetworkIsolationKey, host_resolver_.last_network_isolation_key());
  818. }
  819. TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
  820. CreateProxyResolver();
  821. proxy_resolver_mojo_.reset();
  822. }
  823. } // namespace network