spdy_test_util_common.cc 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045
  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. #include "net/spdy/spdy_test_util_common.h"
  5. #include <cstddef>
  6. #include <utility>
  7. #include "base/base64.h"
  8. #include "base/bind.h"
  9. #include "base/check_op.h"
  10. #include "base/compiler_specific.h"
  11. #include "base/containers/span.h"
  12. #include "base/notreached.h"
  13. #include "base/strings/abseil_string_conversions.h"
  14. #include "base/strings/string_number_conversions.h"
  15. #include "base/strings/string_piece.h"
  16. #include "base/strings/string_split.h"
  17. #include "build/build_config.h"
  18. #include "net/base/host_port_pair.h"
  19. #include "net/base/http_user_agent_settings.h"
  20. #include "net/cert/ct_policy_enforcer.h"
  21. #include "net/cert/ct_policy_status.h"
  22. #include "net/cert/mock_cert_verifier.h"
  23. #include "net/cert/signed_certificate_timestamp_and_status.h"
  24. #include "net/dns/host_resolver.h"
  25. #include "net/dns/public/secure_dns_policy.h"
  26. #include "net/http/http_cache.h"
  27. #include "net/http/http_network_transaction.h"
  28. #include "net/http/http_proxy_connect_job.h"
  29. #include "net/log/net_log_with_source.h"
  30. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  31. #include "net/quic/quic_context.h"
  32. #include "net/socket/client_socket_handle.h"
  33. #include "net/socket/next_proto.h"
  34. #include "net/socket/socket_tag.h"
  35. #include "net/socket/socks_connect_job.h"
  36. #include "net/socket/ssl_client_socket.h"
  37. #include "net/socket/transport_client_socket_pool.h"
  38. #include "net/spdy/buffered_spdy_framer.h"
  39. #include "net/spdy/spdy_http_utils.h"
  40. #include "net/spdy/spdy_stream.h"
  41. #include "net/ssl/ssl_connection_status_flags.h"
  42. #include "net/test/gtest_util.h"
  43. #include "net/third_party/quiche/src/quiche/spdy/core/spdy_alt_svc_wire_format.h"
  44. #include "net/third_party/quiche/src/quiche/spdy/core/spdy_framer.h"
  45. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  46. #include "net/url_request/static_http_user_agent_settings.h"
  47. #include "net/url_request/url_request_context_builder.h"
  48. #include "net/url_request/url_request_job_factory.h"
  49. #include "net/url_request/url_request_test_util.h"
  50. #include "testing/gmock/include/gmock/gmock.h"
  51. #include "third_party/abseil-cpp/absl/types/optional.h"
  52. #include "url/scheme_host_port.h"
  53. #include "url/url_constants.h"
  54. using net::test::IsError;
  55. using net::test::IsOk;
  56. namespace net {
  57. namespace {
  58. // Parses a URL into the scheme, host, and path components required for a
  59. // SPDY request.
  60. void ParseUrl(base::StringPiece url,
  61. std::string* scheme,
  62. std::string* host,
  63. std::string* path) {
  64. GURL gurl(url);
  65. path->assign(gurl.PathForRequest());
  66. scheme->assign(gurl.scheme());
  67. host->assign(gurl.host());
  68. if (gurl.has_port()) {
  69. host->append(":");
  70. host->append(gurl.port());
  71. }
  72. }
  73. } // namespace
  74. // Chop a frame into an array of MockWrites.
  75. // |frame| is the frame to chop.
  76. // |num_chunks| is the number of chunks to create.
  77. std::unique_ptr<MockWrite[]> ChopWriteFrame(
  78. const spdy::SpdySerializedFrame& frame,
  79. int num_chunks) {
  80. auto chunks = std::make_unique<MockWrite[]>(num_chunks);
  81. int chunk_size = frame.size() / num_chunks;
  82. for (int index = 0; index < num_chunks; index++) {
  83. const char* ptr = frame.data() + (index * chunk_size);
  84. if (index == num_chunks - 1)
  85. chunk_size +=
  86. frame.size() % chunk_size; // The last chunk takes the remainder.
  87. chunks[index] = MockWrite(ASYNC, ptr, chunk_size);
  88. }
  89. return chunks;
  90. }
  91. // Adds headers and values to a map.
  92. // |extra_headers| is an array of { name, value } pairs, arranged as strings
  93. // where the even entries are the header names, and the odd entries are the
  94. // header values.
  95. // |headers| gets filled in from |extra_headers|.
  96. void AppendToHeaderBlock(const char* const extra_headers[],
  97. int extra_header_count,
  98. spdy::Http2HeaderBlock* headers) {
  99. if (!extra_header_count)
  100. return;
  101. // Sanity check: Non-NULL header list.
  102. DCHECK(extra_headers) << "NULL header value pair list";
  103. // Sanity check: Non-NULL header map.
  104. DCHECK(headers) << "NULL header map";
  105. // Copy in the headers.
  106. for (int i = 0; i < extra_header_count; i++) {
  107. absl::string_view key(extra_headers[i * 2]);
  108. absl::string_view value(extra_headers[i * 2 + 1]);
  109. DCHECK(!key.empty()) << "Header key must not be empty.";
  110. headers->AppendValueOrAddHeader(key, value);
  111. }
  112. }
  113. // Create a MockWrite from the given spdy::SpdySerializedFrame.
  114. MockWrite CreateMockWrite(const spdy::SpdySerializedFrame& req) {
  115. return MockWrite(ASYNC, req.data(), req.size());
  116. }
  117. // Create a MockWrite from the given spdy::SpdySerializedFrame and sequence
  118. // number.
  119. MockWrite CreateMockWrite(const spdy::SpdySerializedFrame& req, int seq) {
  120. return CreateMockWrite(req, seq, ASYNC);
  121. }
  122. // Create a MockWrite from the given spdy::SpdySerializedFrame and sequence
  123. // number.
  124. MockWrite CreateMockWrite(const spdy::SpdySerializedFrame& req,
  125. int seq,
  126. IoMode mode) {
  127. return MockWrite(mode, req.data(), req.size(), seq);
  128. }
  129. // Create a MockRead from the given spdy::SpdySerializedFrame.
  130. MockRead CreateMockRead(const spdy::SpdySerializedFrame& resp) {
  131. return MockRead(ASYNC, resp.data(), resp.size());
  132. }
  133. // Create a MockRead from the given spdy::SpdySerializedFrame and sequence
  134. // number.
  135. MockRead CreateMockRead(const spdy::SpdySerializedFrame& resp, int seq) {
  136. return CreateMockRead(resp, seq, ASYNC);
  137. }
  138. // Create a MockRead from the given spdy::SpdySerializedFrame and sequence
  139. // number.
  140. MockRead CreateMockRead(const spdy::SpdySerializedFrame& resp,
  141. int seq,
  142. IoMode mode) {
  143. return MockRead(mode, resp.data(), resp.size(), seq);
  144. }
  145. // Combines the given vector of spdy::SpdySerializedFrame into a single frame.
  146. spdy::SpdySerializedFrame CombineFrames(
  147. std::vector<const spdy::SpdySerializedFrame*> frames) {
  148. int total_size = 0;
  149. for (const auto* frame : frames) {
  150. total_size += frame->size();
  151. }
  152. auto data = std::make_unique<char[]>(total_size);
  153. char* ptr = data.get();
  154. for (const auto* frame : frames) {
  155. memcpy(ptr, frame->data(), frame->size());
  156. ptr += frame->size();
  157. }
  158. return spdy::SpdySerializedFrame(data.release(), total_size,
  159. /* owns_buffer = */ true);
  160. }
  161. namespace {
  162. class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
  163. public:
  164. PriorityGetter() = default;
  165. ~PriorityGetter() override = default;
  166. spdy::SpdyPriority priority() const { return priority_; }
  167. void OnError(
  168. http2::Http2DecoderAdapter::SpdyFramerError spdy_framer_error) override {}
  169. void OnStreamError(spdy::SpdyStreamId stream_id,
  170. const std::string& description) override {}
  171. void OnHeaders(spdy::SpdyStreamId stream_id,
  172. bool has_priority,
  173. int weight,
  174. spdy::SpdyStreamId parent_stream_id,
  175. bool exclusive,
  176. bool fin,
  177. spdy::Http2HeaderBlock headers,
  178. base::TimeTicks recv_first_byte_time) override {
  179. if (has_priority) {
  180. priority_ = spdy::Http2WeightToSpdy3Priority(weight);
  181. }
  182. }
  183. void OnDataFrameHeader(spdy::SpdyStreamId stream_id,
  184. size_t length,
  185. bool fin) override {}
  186. void OnStreamFrameData(spdy::SpdyStreamId stream_id,
  187. const char* data,
  188. size_t len) override {}
  189. void OnStreamEnd(spdy::SpdyStreamId stream_id) override {}
  190. void OnStreamPadding(spdy::SpdyStreamId stream_id, size_t len) override {}
  191. void OnSettings() override {}
  192. void OnSettingsAck() override {}
  193. void OnSetting(spdy::SpdySettingsId id, uint32_t value) override {}
  194. void OnSettingsEnd() override {}
  195. void OnPing(spdy::SpdyPingId unique_id, bool is_ack) override {}
  196. void OnRstStream(spdy::SpdyStreamId stream_id,
  197. spdy::SpdyErrorCode error_code) override {}
  198. void OnGoAway(spdy::SpdyStreamId last_accepted_stream_id,
  199. spdy::SpdyErrorCode error_code,
  200. base::StringPiece debug_data) override {}
  201. void OnWindowUpdate(spdy::SpdyStreamId stream_id,
  202. int delta_window_size) override {}
  203. void OnPushPromise(spdy::SpdyStreamId stream_id,
  204. spdy::SpdyStreamId promised_stream_id,
  205. spdy::Http2HeaderBlock headers) override {}
  206. void OnAltSvc(spdy::SpdyStreamId stream_id,
  207. base::StringPiece origin,
  208. const spdy::SpdyAltSvcWireFormat::AlternativeServiceVector&
  209. altsvc_vector) override {}
  210. bool OnUnknownFrame(spdy::SpdyStreamId stream_id,
  211. uint8_t frame_type) override {
  212. return false;
  213. }
  214. private:
  215. spdy::SpdyPriority priority_ = 0;
  216. };
  217. } // namespace
  218. bool GetSpdyPriority(const spdy::SpdySerializedFrame& frame,
  219. spdy::SpdyPriority* priority) {
  220. NetLogWithSource net_log;
  221. BufferedSpdyFramer framer(kMaxHeaderListSizeForTest, net_log);
  222. PriorityGetter priority_getter;
  223. framer.set_visitor(&priority_getter);
  224. size_t frame_size = frame.size();
  225. if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
  226. return false;
  227. }
  228. *priority = priority_getter.priority();
  229. return true;
  230. }
  231. base::WeakPtr<SpdyStream> CreateStreamSynchronously(
  232. SpdyStreamType type,
  233. const base::WeakPtr<SpdySession>& session,
  234. const GURL& url,
  235. RequestPriority priority,
  236. const NetLogWithSource& net_log,
  237. bool detect_broken_connection,
  238. base::TimeDelta heartbeat_interval) {
  239. SpdyStreamRequest stream_request;
  240. int rv = stream_request.StartRequest(
  241. type, session, url, false /* no early data */, priority, SocketTag(),
  242. net_log, CompletionOnceCallback(), TRAFFIC_ANNOTATION_FOR_TESTS,
  243. detect_broken_connection, heartbeat_interval);
  244. return
  245. (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
  246. }
  247. StreamReleaserCallback::StreamReleaserCallback() = default;
  248. StreamReleaserCallback::~StreamReleaserCallback() = default;
  249. CompletionOnceCallback StreamReleaserCallback::MakeCallback(
  250. SpdyStreamRequest* request) {
  251. return base::BindOnce(&StreamReleaserCallback::OnComplete,
  252. base::Unretained(this), request);
  253. }
  254. void StreamReleaserCallback::OnComplete(
  255. SpdyStreamRequest* request, int result) {
  256. if (result == OK)
  257. request->ReleaseStream()->Cancel(ERR_ABORTED);
  258. SetResult(result);
  259. }
  260. SpdySessionDependencies::SpdySessionDependencies()
  261. : SpdySessionDependencies(
  262. ConfiguredProxyResolutionService::CreateDirect()) {}
  263. SpdySessionDependencies::SpdySessionDependencies(
  264. std::unique_ptr<ProxyResolutionService> proxy_resolution_service)
  265. : host_resolver(std::make_unique<MockCachingHostResolver>(
  266. /*cache_invalidation_num=*/0,
  267. MockHostResolverBase::RuleResolver::GetLocalhostResult())),
  268. cert_verifier(std::make_unique<MockCertVerifier>()),
  269. transport_security_state(std::make_unique<TransportSecurityState>()),
  270. ct_policy_enforcer(std::make_unique<DefaultCTPolicyEnforcer>()),
  271. proxy_resolution_service(std::move(proxy_resolution_service)),
  272. ssl_config_service(std::make_unique<SSLConfigServiceDefaults>()),
  273. socket_factory(std::make_unique<MockClientSocketFactory>()),
  274. http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
  275. http_server_properties(std::make_unique<HttpServerProperties>()),
  276. quic_context(std::make_unique<QuicContext>()),
  277. time_func(&base::TimeTicks::Now) {
  278. http2_settings[spdy::SETTINGS_INITIAL_WINDOW_SIZE] =
  279. kDefaultInitialWindowSize;
  280. }
  281. SpdySessionDependencies::SpdySessionDependencies(SpdySessionDependencies&&) =
  282. default;
  283. SpdySessionDependencies::~SpdySessionDependencies() = default;
  284. SpdySessionDependencies& SpdySessionDependencies::operator=(
  285. SpdySessionDependencies&&) = default;
  286. // static
  287. std::unique_ptr<HttpNetworkSession> SpdySessionDependencies::SpdyCreateSession(
  288. SpdySessionDependencies* session_deps) {
  289. return SpdyCreateSessionWithSocketFactory(session_deps,
  290. session_deps->socket_factory.get());
  291. }
  292. // static
  293. std::unique_ptr<HttpNetworkSession>
  294. SpdySessionDependencies::SpdyCreateSessionWithSocketFactory(
  295. SpdySessionDependencies* session_deps,
  296. ClientSocketFactory* factory) {
  297. HttpNetworkSessionParams session_params = CreateSessionParams(session_deps);
  298. HttpNetworkSessionContext session_context =
  299. CreateSessionContext(session_deps);
  300. session_context.client_socket_factory = factory;
  301. auto http_session =
  302. std::make_unique<HttpNetworkSession>(session_params, session_context);
  303. SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool());
  304. pool_peer.SetEnableSendingInitialData(false);
  305. return http_session;
  306. }
  307. // static
  308. HttpNetworkSessionParams SpdySessionDependencies::CreateSessionParams(
  309. SpdySessionDependencies* session_deps) {
  310. HttpNetworkSessionParams params;
  311. params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
  312. params.enable_user_alternate_protocol_ports =
  313. session_deps->enable_user_alternate_protocol_ports;
  314. params.enable_quic = session_deps->enable_quic;
  315. params.enable_server_push_cancellation =
  316. session_deps->enable_server_push_cancellation;
  317. params.spdy_session_max_recv_window_size =
  318. session_deps->session_max_recv_window_size;
  319. params.spdy_session_max_queued_capped_frames =
  320. session_deps->session_max_queued_capped_frames;
  321. params.http2_settings = session_deps->http2_settings;
  322. params.time_func = session_deps->time_func;
  323. params.enable_http2_alternative_service =
  324. session_deps->enable_http2_alternative_service;
  325. params.enable_http2_settings_grease =
  326. session_deps->enable_http2_settings_grease;
  327. params.greased_http2_frame = session_deps->greased_http2_frame;
  328. params.http2_end_stream_with_data_frame =
  329. session_deps->http2_end_stream_with_data_frame;
  330. params.disable_idle_sockets_close_on_memory_pressure =
  331. session_deps->disable_idle_sockets_close_on_memory_pressure;
  332. params.enable_early_data = session_deps->enable_early_data;
  333. params.key_auth_cache_server_entries_by_network_isolation_key =
  334. session_deps->key_auth_cache_server_entries_by_network_isolation_key;
  335. params.enable_priority_update = session_deps->enable_priority_update;
  336. params.spdy_go_away_on_ip_change = session_deps->go_away_on_ip_change;
  337. params.ignore_ip_address_changes = session_deps->ignore_ip_address_changes;
  338. return params;
  339. }
  340. HttpNetworkSessionContext SpdySessionDependencies::CreateSessionContext(
  341. SpdySessionDependencies* session_deps) {
  342. HttpNetworkSessionContext context;
  343. context.client_socket_factory = session_deps->socket_factory.get();
  344. context.host_resolver = session_deps->GetHostResolver();
  345. context.cert_verifier = session_deps->cert_verifier.get();
  346. context.transport_security_state =
  347. session_deps->transport_security_state.get();
  348. context.ct_policy_enforcer = session_deps->ct_policy_enforcer.get();
  349. context.proxy_resolution_service =
  350. session_deps->proxy_resolution_service.get();
  351. context.http_user_agent_settings =
  352. session_deps->http_user_agent_settings.get();
  353. context.ssl_config_service = session_deps->ssl_config_service.get();
  354. context.http_auth_handler_factory =
  355. session_deps->http_auth_handler_factory.get();
  356. context.http_server_properties = session_deps->http_server_properties.get();
  357. context.quic_context = session_deps->quic_context.get();
  358. context.net_log = session_deps->net_log;
  359. #if BUILDFLAG(ENABLE_REPORTING)
  360. context.reporting_service = session_deps->reporting_service.get();
  361. context.network_error_logging_service =
  362. session_deps->network_error_logging_service.get();
  363. #endif
  364. return context;
  365. }
  366. std::unique_ptr<URLRequestContextBuilder>
  367. CreateSpdyTestURLRequestContextBuilder(
  368. ClientSocketFactory* client_socket_factory) {
  369. auto builder = CreateTestURLRequestContextBuilder();
  370. builder->set_client_socket_factory_for_testing( // IN-TEST
  371. client_socket_factory);
  372. builder->set_host_resolver(std::make_unique<MockHostResolver>(
  373. /*default_result=*/MockHostResolverBase::RuleResolver::
  374. GetLocalhostResult()));
  375. builder->SetCertVerifier(std::make_unique<MockCertVerifier>());
  376. HttpNetworkSessionParams session_params;
  377. session_params.enable_spdy_ping_based_connection_checking = false;
  378. builder->set_http_network_session_params(session_params);
  379. builder->set_http_user_agent_settings(
  380. std::make_unique<StaticHttpUserAgentSettings>("", ""));
  381. return builder;
  382. }
  383. bool HasSpdySession(SpdySessionPool* pool, const SpdySessionKey& key) {
  384. return static_cast<bool>(pool->FindAvailableSession(
  385. key, /* enable_ip_based_pooling = */ true,
  386. /* is_websocket = */ false, NetLogWithSource()));
  387. }
  388. namespace {
  389. base::WeakPtr<SpdySession> CreateSpdySessionHelper(
  390. HttpNetworkSession* http_session,
  391. const SpdySessionKey& key,
  392. const NetLogWithSource& net_log,
  393. bool enable_ip_based_pooling) {
  394. EXPECT_FALSE(http_session->spdy_session_pool()->FindAvailableSession(
  395. key, enable_ip_based_pooling,
  396. /*is_websocket=*/false, NetLogWithSource()));
  397. auto connection = std::make_unique<ClientSocketHandle>();
  398. TestCompletionCallback callback;
  399. auto ssl_config = std::make_unique<SSLConfig>();
  400. ssl_config->alpn_protos = http_session->GetAlpnProtos();
  401. scoped_refptr<ClientSocketPool::SocketParams> socket_params =
  402. base::MakeRefCounted<ClientSocketPool::SocketParams>(
  403. /*ssl_config_for_origin=*/std::move(ssl_config),
  404. /*ssl_config_for_proxy=*/nullptr);
  405. int rv = connection->Init(
  406. ClientSocketPool::GroupId(
  407. url::SchemeHostPort(url::kHttpsScheme,
  408. key.host_port_pair().HostForURL(),
  409. key.host_port_pair().port()),
  410. key.privacy_mode(), NetworkIsolationKey(), SecureDnsPolicy::kAllow),
  411. socket_params, /*proxy_annotation_tag=*/absl::nullopt, MEDIUM,
  412. key.socket_tag(), ClientSocketPool::RespectLimits::ENABLED,
  413. callback.callback(), ClientSocketPool::ProxyAuthCallback(),
  414. http_session->GetSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL,
  415. ProxyServer::Direct()),
  416. net_log);
  417. rv = callback.GetResult(rv);
  418. EXPECT_THAT(rv, IsOk());
  419. base::WeakPtr<SpdySession> spdy_session;
  420. rv =
  421. http_session->spdy_session_pool()->CreateAvailableSessionFromSocketHandle(
  422. key, std::move(connection), net_log, &spdy_session);
  423. // Failure is reported asynchronously.
  424. EXPECT_THAT(rv, IsOk());
  425. EXPECT_TRUE(spdy_session);
  426. EXPECT_TRUE(HasSpdySession(http_session->spdy_session_pool(), key));
  427. // Disable the time-based receive window updates by setting the delay to
  428. // the max time interval. This prevents time-based flakiness in the tests
  429. // for any test not explicitly exercising the window update buffering.
  430. spdy_session->SetTimeToBufferSmallWindowUpdates(base::TimeDelta::Max());
  431. return spdy_session;
  432. }
  433. } // namespace
  434. base::WeakPtr<SpdySession> CreateSpdySession(HttpNetworkSession* http_session,
  435. const SpdySessionKey& key,
  436. const NetLogWithSource& net_log) {
  437. return CreateSpdySessionHelper(http_session, key, net_log,
  438. /* enable_ip_based_pooling = */ true);
  439. }
  440. base::WeakPtr<SpdySession> CreateSpdySessionWithIpBasedPoolingDisabled(
  441. HttpNetworkSession* http_session,
  442. const SpdySessionKey& key,
  443. const NetLogWithSource& net_log) {
  444. return CreateSpdySessionHelper(http_session, key, net_log,
  445. /* enable_ip_based_pooling = */ false);
  446. }
  447. namespace {
  448. // A ClientSocket used for CreateFakeSpdySession() below.
  449. class FakeSpdySessionClientSocket : public MockClientSocket {
  450. public:
  451. FakeSpdySessionClientSocket() : MockClientSocket(NetLogWithSource()) {}
  452. ~FakeSpdySessionClientSocket() override = default;
  453. int Read(IOBuffer* buf,
  454. int buf_len,
  455. CompletionOnceCallback callback) override {
  456. return ERR_IO_PENDING;
  457. }
  458. int Write(IOBuffer* buf,
  459. int buf_len,
  460. CompletionOnceCallback callback,
  461. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  462. return ERR_IO_PENDING;
  463. }
  464. // Return kProtoUnknown to use the pool's default protocol.
  465. NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
  466. // The functions below are not expected to be called.
  467. int Connect(CompletionOnceCallback callback) override {
  468. ADD_FAILURE();
  469. return ERR_UNEXPECTED;
  470. }
  471. bool WasEverUsed() const override {
  472. ADD_FAILURE();
  473. return false;
  474. }
  475. bool WasAlpnNegotiated() const override {
  476. ADD_FAILURE();
  477. return false;
  478. }
  479. bool GetSSLInfo(SSLInfo* ssl_info) override {
  480. SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_3,
  481. &ssl_info->connection_status);
  482. SSLConnectionStatusSetCipherSuite(0x1301 /* TLS_CHACHA20_POLY1305_SHA256 */,
  483. &ssl_info->connection_status);
  484. return true;
  485. }
  486. int64_t GetTotalReceivedBytes() const override {
  487. NOTIMPLEMENTED();
  488. return 0;
  489. }
  490. };
  491. } // namespace
  492. base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
  493. const SpdySessionKey& key) {
  494. EXPECT_FALSE(HasSpdySession(pool, key));
  495. auto handle = std::make_unique<ClientSocketHandle>();
  496. handle->SetSocket(std::make_unique<FakeSpdySessionClientSocket>());
  497. base::WeakPtr<SpdySession> spdy_session;
  498. int rv = pool->CreateAvailableSessionFromSocketHandle(
  499. key, std::move(handle), NetLogWithSource(), &spdy_session);
  500. // Failure is reported asynchronously.
  501. EXPECT_THAT(rv, IsOk());
  502. EXPECT_TRUE(spdy_session);
  503. EXPECT_TRUE(HasSpdySession(pool, key));
  504. // Disable the time-based receive window updates by setting the delay to
  505. // the max time interval. This prevents time-based flakiness in the tests
  506. // for any test not explicitly exercising the window update buffering.
  507. spdy_session->SetTimeToBufferSmallWindowUpdates(base::TimeDelta::Max());
  508. return spdy_session;
  509. }
  510. SpdySessionPoolPeer::SpdySessionPoolPeer(SpdySessionPool* pool) : pool_(pool) {
  511. }
  512. void SpdySessionPoolPeer::RemoveAliases(const SpdySessionKey& key) {
  513. pool_->RemoveAliases(key);
  514. }
  515. void SpdySessionPoolPeer::SetEnableSendingInitialData(bool enabled) {
  516. pool_->enable_sending_initial_data_ = enabled;
  517. }
  518. SpdyTestUtil::SpdyTestUtil()
  519. : headerless_spdy_framer_(spdy::SpdyFramer::ENABLE_COMPRESSION),
  520. request_spdy_framer_(spdy::SpdyFramer::ENABLE_COMPRESSION),
  521. response_spdy_framer_(spdy::SpdyFramer::ENABLE_COMPRESSION),
  522. default_url_(GURL(kDefaultUrl)) {}
  523. SpdyTestUtil::~SpdyTestUtil() = default;
  524. void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
  525. spdy::Http2HeaderBlock* headers) const {
  526. std::string scheme, host, path;
  527. ParseUrl(url, &scheme, &host, &path);
  528. (*headers)[spdy::kHttp2AuthorityHeader] = host;
  529. (*headers)[spdy::kHttp2SchemeHeader] = scheme;
  530. (*headers)[spdy::kHttp2PathHeader] = path;
  531. }
  532. // static
  533. spdy::Http2HeaderBlock SpdyTestUtil::ConstructGetHeaderBlock(
  534. base::StringPiece url) {
  535. return ConstructHeaderBlock("GET", url, nullptr);
  536. }
  537. // static
  538. spdy::Http2HeaderBlock SpdyTestUtil::ConstructGetHeaderBlockForProxy(
  539. base::StringPiece url) {
  540. return ConstructGetHeaderBlock(url);
  541. }
  542. // static
  543. spdy::Http2HeaderBlock SpdyTestUtil::ConstructHeadHeaderBlock(
  544. base::StringPiece url,
  545. int64_t content_length) {
  546. return ConstructHeaderBlock("HEAD", url, nullptr);
  547. }
  548. // static
  549. spdy::Http2HeaderBlock SpdyTestUtil::ConstructPostHeaderBlock(
  550. base::StringPiece url,
  551. int64_t content_length) {
  552. return ConstructHeaderBlock("POST", url, &content_length);
  553. }
  554. // static
  555. spdy::Http2HeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(
  556. base::StringPiece url,
  557. int64_t content_length) {
  558. return ConstructHeaderBlock("PUT", url, &content_length);
  559. }
  560. std::string SpdyTestUtil::ConstructSpdyReplyString(
  561. const spdy::Http2HeaderBlock& headers) const {
  562. std::string reply_string;
  563. for (spdy::Http2HeaderBlock::const_iterator it = headers.begin();
  564. it != headers.end(); ++it) {
  565. auto key = std::string(it->first);
  566. // Remove leading colon from pseudo headers.
  567. if (key[0] == ':')
  568. key = key.substr(1);
  569. for (const std::string& value :
  570. base::SplitString(base::StringViewToStringPiece(it->second),
  571. base::StringPiece("\0", 1), base::TRIM_WHITESPACE,
  572. base::SPLIT_WANT_ALL)) {
  573. reply_string += key + ": " + value + "\n";
  574. }
  575. }
  576. return reply_string;
  577. }
  578. // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
  579. // spdy::SpdySettingsIR).
  580. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdySettings(
  581. const spdy::SettingsMap& settings) {
  582. spdy::SpdySettingsIR settings_ir;
  583. for (const auto& setting : settings) {
  584. settings_ir.AddSetting(setting.first, setting.second);
  585. }
  586. return spdy::SpdySerializedFrame(
  587. headerless_spdy_framer_.SerializeFrame(settings_ir));
  588. }
  589. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdySettingsAck() {
  590. spdy::SpdySettingsIR settings_ir;
  591. settings_ir.set_is_ack(true);
  592. return spdy::SpdySerializedFrame(
  593. headerless_spdy_framer_.SerializeFrame(settings_ir));
  594. }
  595. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPing(uint32_t ping_id,
  596. bool is_ack) {
  597. spdy::SpdyPingIR ping_ir(ping_id);
  598. ping_ir.set_is_ack(is_ack);
  599. return spdy::SpdySerializedFrame(
  600. headerless_spdy_framer_.SerializeFrame(ping_ir));
  601. }
  602. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyGoAway(
  603. spdy::SpdyStreamId last_good_stream_id) {
  604. spdy::SpdyGoAwayIR go_ir(last_good_stream_id, spdy::ERROR_CODE_NO_ERROR,
  605. "go away");
  606. return spdy::SpdySerializedFrame(
  607. headerless_spdy_framer_.SerializeFrame(go_ir));
  608. }
  609. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyGoAway(
  610. spdy::SpdyStreamId last_good_stream_id,
  611. spdy::SpdyErrorCode error_code,
  612. const std::string& desc) {
  613. spdy::SpdyGoAwayIR go_ir(last_good_stream_id, error_code, desc);
  614. return spdy::SpdySerializedFrame(
  615. headerless_spdy_framer_.SerializeFrame(go_ir));
  616. }
  617. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyWindowUpdate(
  618. const spdy::SpdyStreamId stream_id,
  619. uint32_t delta_window_size) {
  620. spdy::SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
  621. return spdy::SpdySerializedFrame(
  622. headerless_spdy_framer_.SerializeFrame(update_ir));
  623. }
  624. // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
  625. // spdy::SpdyRstStreamIR).
  626. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyRstStream(
  627. spdy::SpdyStreamId stream_id,
  628. spdy::SpdyErrorCode error_code) {
  629. spdy::SpdyRstStreamIR rst_ir(stream_id, error_code);
  630. return spdy::SpdySerializedFrame(
  631. headerless_spdy_framer_.SerializeRstStream(rst_ir));
  632. }
  633. // TODO(jgraettinger): Eliminate uses of this method in tests (prefer
  634. // spdy::SpdyPriorityIR).
  635. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPriority(
  636. spdy::SpdyStreamId stream_id,
  637. spdy::SpdyStreamId parent_stream_id,
  638. RequestPriority request_priority,
  639. bool exclusive) {
  640. int weight = spdy::Spdy3PriorityToHttp2Weight(
  641. ConvertRequestPriorityToSpdyPriority(request_priority));
  642. spdy::SpdyPriorityIR ir(stream_id, parent_stream_id, weight, exclusive);
  643. return spdy::SpdySerializedFrame(
  644. headerless_spdy_framer_.SerializePriority(ir));
  645. }
  646. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyGet(
  647. const char* const url,
  648. spdy::SpdyStreamId stream_id,
  649. RequestPriority request_priority) {
  650. spdy::Http2HeaderBlock block(ConstructGetHeaderBlock(url));
  651. return ConstructSpdyHeaders(stream_id, std::move(block), request_priority,
  652. true);
  653. }
  654. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyGet(
  655. const char* const extra_headers[],
  656. int extra_header_count,
  657. int stream_id,
  658. RequestPriority request_priority) {
  659. spdy::Http2HeaderBlock block;
  660. block[spdy::kHttp2MethodHeader] = "GET";
  661. AddUrlToHeaderBlock(default_url_.spec(), &block);
  662. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  663. return ConstructSpdyHeaders(stream_id, std::move(block), request_priority,
  664. true);
  665. }
  666. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyConnect(
  667. const char* const extra_headers[],
  668. int extra_header_count,
  669. int stream_id,
  670. RequestPriority priority,
  671. const HostPortPair& host_port_pair) {
  672. spdy::Http2HeaderBlock block;
  673. block[spdy::kHttp2MethodHeader] = "CONNECT";
  674. block[spdy::kHttp2AuthorityHeader] = host_port_pair.ToString();
  675. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  676. return ConstructSpdyHeaders(stream_id, std::move(block), priority, false);
  677. }
  678. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPush(
  679. const char* const extra_headers[],
  680. int extra_header_count,
  681. int stream_id,
  682. int associated_stream_id,
  683. const char* url) {
  684. spdy::Http2HeaderBlock push_promise_header_block;
  685. push_promise_header_block[spdy::kHttp2MethodHeader] = "GET";
  686. AddUrlToHeaderBlock(url, &push_promise_header_block);
  687. spdy::SpdySerializedFrame push_promise_frame(ConstructSpdyPushPromise(
  688. associated_stream_id, stream_id, std::move(push_promise_header_block)));
  689. spdy::Http2HeaderBlock headers_header_block;
  690. headers_header_block[spdy::kHttp2StatusHeader] = "200";
  691. headers_header_block["hello"] = "bye";
  692. AppendToHeaderBlock(extra_headers, extra_header_count, &headers_header_block);
  693. spdy::SpdyHeadersIR headers(stream_id, std::move(headers_header_block));
  694. spdy::SpdySerializedFrame headers_frame(
  695. response_spdy_framer_.SerializeFrame(headers));
  696. return CombineFrames({&push_promise_frame, &headers_frame});
  697. }
  698. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPush(
  699. const char* const extra_headers[],
  700. int extra_header_count,
  701. int stream_id,
  702. int associated_stream_id,
  703. const char* url,
  704. const char* status,
  705. const char* location) {
  706. spdy::Http2HeaderBlock push_promise_header_block;
  707. push_promise_header_block[spdy::kHttp2MethodHeader] = "GET";
  708. AddUrlToHeaderBlock(url, &push_promise_header_block);
  709. spdy::SpdySerializedFrame push_promise_frame(ConstructSpdyPushPromise(
  710. associated_stream_id, stream_id, std::move(push_promise_header_block)));
  711. spdy::Http2HeaderBlock headers_header_block;
  712. headers_header_block["hello"] = "bye";
  713. headers_header_block[spdy::kHttp2StatusHeader] = status;
  714. headers_header_block["location"] = location;
  715. AppendToHeaderBlock(extra_headers, extra_header_count, &headers_header_block);
  716. spdy::SpdyHeadersIR headers(stream_id, std::move(headers_header_block));
  717. spdy::SpdySerializedFrame headers_frame(
  718. response_spdy_framer_.SerializeFrame(headers));
  719. return CombineFrames({&push_promise_frame, &headers_frame});
  720. }
  721. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPushPromise(
  722. spdy::SpdyStreamId associated_stream_id,
  723. spdy::SpdyStreamId stream_id,
  724. spdy::Http2HeaderBlock headers) {
  725. spdy::SpdyPushPromiseIR push_promise(associated_stream_id, stream_id,
  726. std::move(headers));
  727. return spdy::SpdySerializedFrame(
  728. response_spdy_framer_.SerializeFrame(push_promise));
  729. }
  730. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPushHeaders(
  731. int stream_id,
  732. const char* const extra_headers[],
  733. int extra_header_count) {
  734. spdy::Http2HeaderBlock header_block;
  735. header_block[spdy::kHttp2StatusHeader] = "200";
  736. AppendToHeaderBlock(extra_headers, extra_header_count, &header_block);
  737. spdy::SpdyHeadersIR headers(stream_id, std::move(header_block));
  738. return spdy::SpdySerializedFrame(
  739. response_spdy_framer_.SerializeFrame(headers));
  740. }
  741. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyResponseHeaders(
  742. int stream_id,
  743. spdy::Http2HeaderBlock headers,
  744. bool fin) {
  745. spdy::SpdyHeadersIR spdy_headers(stream_id, std::move(headers));
  746. spdy_headers.set_fin(fin);
  747. return spdy::SpdySerializedFrame(
  748. response_spdy_framer_.SerializeFrame(spdy_headers));
  749. }
  750. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyHeaders(
  751. int stream_id,
  752. spdy::Http2HeaderBlock block,
  753. RequestPriority priority,
  754. bool fin) {
  755. // Get the stream id of the next highest priority request
  756. // (most recent request of the same priority, or last request of
  757. // an earlier priority).
  758. // Note that this is a duplicate of the logic in Http2PriorityDependencies
  759. // (slightly transformed as this is based on RequestPriority and that logic
  760. // on spdy::SpdyPriority, but only slightly transformed) and hence tests using
  761. // this function do not effectively test that logic.
  762. // That logic is tested by the Http2PriorityDependencies unit tests.
  763. int parent_stream_id = 0;
  764. for (int q = priority; q <= HIGHEST; ++q) {
  765. if (!priority_to_stream_id_list_[q].empty()) {
  766. parent_stream_id = priority_to_stream_id_list_[q].back();
  767. break;
  768. }
  769. }
  770. priority_to_stream_id_list_[priority].push_back(stream_id);
  771. spdy::SpdyHeadersIR headers(stream_id, std::move(block));
  772. headers.set_has_priority(true);
  773. headers.set_weight(spdy::Spdy3PriorityToHttp2Weight(
  774. ConvertRequestPriorityToSpdyPriority(priority)));
  775. headers.set_parent_stream_id(parent_stream_id);
  776. headers.set_exclusive(true);
  777. headers.set_fin(fin);
  778. return spdy::SpdySerializedFrame(
  779. request_spdy_framer_.SerializeFrame(headers));
  780. }
  781. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyReply(
  782. int stream_id,
  783. spdy::Http2HeaderBlock headers) {
  784. spdy::SpdyHeadersIR reply(stream_id, std::move(headers));
  785. return spdy::SpdySerializedFrame(response_spdy_framer_.SerializeFrame(reply));
  786. }
  787. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyReplyError(
  788. const char* const status,
  789. const char* const* const extra_headers,
  790. int extra_header_count,
  791. int stream_id) {
  792. spdy::Http2HeaderBlock block;
  793. block[spdy::kHttp2StatusHeader] = status;
  794. block["hello"] = "bye";
  795. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  796. spdy::SpdyHeadersIR reply(stream_id, std::move(block));
  797. return spdy::SpdySerializedFrame(response_spdy_framer_.SerializeFrame(reply));
  798. }
  799. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyReplyError(int stream_id) {
  800. return ConstructSpdyReplyError("500", nullptr, 0, stream_id);
  801. }
  802. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyGetReply(
  803. const char* const extra_headers[],
  804. int extra_header_count,
  805. int stream_id) {
  806. spdy::Http2HeaderBlock block;
  807. block[spdy::kHttp2StatusHeader] = "200";
  808. block["hello"] = "bye";
  809. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  810. return ConstructSpdyReply(stream_id, std::move(block));
  811. }
  812. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPost(
  813. const char* url,
  814. spdy::SpdyStreamId stream_id,
  815. int64_t content_length,
  816. RequestPriority priority,
  817. const char* const extra_headers[],
  818. int extra_header_count) {
  819. spdy::Http2HeaderBlock block(ConstructPostHeaderBlock(url, content_length));
  820. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  821. return ConstructSpdyHeaders(stream_id, std::move(block), priority, false);
  822. }
  823. spdy::SpdySerializedFrame SpdyTestUtil::ConstructChunkedSpdyPost(
  824. const char* const extra_headers[],
  825. int extra_header_count) {
  826. spdy::Http2HeaderBlock block;
  827. block[spdy::kHttp2MethodHeader] = "POST";
  828. AddUrlToHeaderBlock(default_url_.spec(), &block);
  829. AppendToHeaderBlock(extra_headers, extra_header_count, &block);
  830. return ConstructSpdyHeaders(1, std::move(block), LOWEST, false);
  831. }
  832. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyPostReply(
  833. const char* const extra_headers[],
  834. int extra_header_count) {
  835. // TODO(jgraettinger): Remove this method.
  836. return ConstructSpdyGetReply(extra_headers, extra_header_count, 1);
  837. }
  838. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyDataFrame(int stream_id,
  839. bool fin) {
  840. return ConstructSpdyDataFrame(stream_id, kUploadData, fin);
  841. }
  842. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyDataFrame(
  843. int stream_id,
  844. base::StringPiece data,
  845. bool fin) {
  846. spdy::SpdyDataIR data_ir(stream_id, base::StringPieceToStringView(data));
  847. data_ir.set_fin(fin);
  848. return spdy::SpdySerializedFrame(
  849. headerless_spdy_framer_.SerializeData(data_ir));
  850. }
  851. spdy::SpdySerializedFrame SpdyTestUtil::ConstructSpdyDataFrame(
  852. int stream_id,
  853. base::StringPiece data,
  854. bool fin,
  855. int padding_length) {
  856. spdy::SpdyDataIR data_ir(stream_id, base::StringPieceToStringView(data));
  857. data_ir.set_fin(fin);
  858. data_ir.set_padding_len(padding_length);
  859. return spdy::SpdySerializedFrame(
  860. headerless_spdy_framer_.SerializeData(data_ir));
  861. }
  862. spdy::SpdySerializedFrame SpdyTestUtil::ConstructWrappedSpdyFrame(
  863. const spdy::SpdySerializedFrame& frame,
  864. int stream_id) {
  865. return ConstructSpdyDataFrame(
  866. stream_id, base::StringPiece(frame.data(), frame.size()), false);
  867. }
  868. spdy::SpdySerializedFrame SpdyTestUtil::SerializeFrame(
  869. const spdy::SpdyFrameIR& frame_ir) {
  870. return headerless_spdy_framer_.SerializeFrame(frame_ir);
  871. }
  872. void SpdyTestUtil::UpdateWithStreamDestruction(int stream_id) {
  873. for (auto& priority_it : priority_to_stream_id_list_) {
  874. for (auto stream_it = priority_it.second.begin();
  875. stream_it != priority_it.second.end(); ++stream_it) {
  876. if (*stream_it == stream_id) {
  877. priority_it.second.erase(stream_it);
  878. return;
  879. }
  880. }
  881. }
  882. NOTREACHED();
  883. }
  884. // static
  885. spdy::Http2HeaderBlock SpdyTestUtil::ConstructHeaderBlock(
  886. base::StringPiece method,
  887. base::StringPiece url,
  888. int64_t* content_length) {
  889. std::string scheme, host, path;
  890. ParseUrl(url, &scheme, &host, &path);
  891. spdy::Http2HeaderBlock headers;
  892. headers[spdy::kHttp2MethodHeader] = std::string(method);
  893. headers[spdy::kHttp2AuthorityHeader] = host.c_str();
  894. headers[spdy::kHttp2SchemeHeader] = scheme.c_str();
  895. headers[spdy::kHttp2PathHeader] = path.c_str();
  896. if (content_length) {
  897. std::string length_str = base::NumberToString(*content_length);
  898. headers["content-length"] = length_str;
  899. }
  900. return headers;
  901. }
  902. namespace test {
  903. HashValue GetTestHashValue(uint8_t label) {
  904. HashValue hash_value(HASH_VALUE_SHA256);
  905. memset(hash_value.data(), label, hash_value.size());
  906. return hash_value;
  907. }
  908. TestServerPushDelegate::TestServerPushDelegate() = default;
  909. TestServerPushDelegate::~TestServerPushDelegate() = default;
  910. void TestServerPushDelegate::OnPush(
  911. std::unique_ptr<ServerPushHelper> push_helper,
  912. const NetLogWithSource& session_net_log) {
  913. push_helpers[push_helper->GetURL()] = std::move(push_helper);
  914. }
  915. bool TestServerPushDelegate::CancelPush(GURL url) {
  916. auto itr = push_helpers.find(url);
  917. DCHECK(itr != push_helpers.end());
  918. itr->second->Cancel();
  919. push_helpers.erase(itr);
  920. return true;
  921. }
  922. } // namespace test
  923. } // namespace net