bidirectional_stream_unittest.cc 68 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790
  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 "net/http/bidirectional_stream.h"
  5. #include <memory>
  6. #include <string>
  7. #include <utility>
  8. #include <vector>
  9. #include "base/containers/span.h"
  10. #include "base/memory/ptr_util.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/run_loop.h"
  13. #include "base/strings/string_number_conversions.h"
  14. #include "base/time/time.h"
  15. #include "base/timer/mock_timer.h"
  16. #include "base/timer/timer.h"
  17. #include "build/build_config.h"
  18. #include "net/base/completion_once_callback.h"
  19. #include "net/base/load_timing_info.h"
  20. #include "net/base/load_timing_info_test_util.h"
  21. #include "net/base/net_errors.h"
  22. #include "net/dns/public/secure_dns_policy.h"
  23. #include "net/http/bidirectional_stream_request_info.h"
  24. #include "net/http/http_network_session.h"
  25. #include "net/http/http_response_headers.h"
  26. #include "net/http/http_server_properties.h"
  27. #include "net/log/net_log.h"
  28. #include "net/log/net_log_capture_mode.h"
  29. #include "net/log/net_log_event_type.h"
  30. #include "net/log/net_log_source_type.h"
  31. #include "net/log/test_net_log.h"
  32. #include "net/log/test_net_log_util.h"
  33. #include "net/socket/socket_tag.h"
  34. #include "net/socket/socket_test_util.h"
  35. #include "net/spdy/spdy_session.h"
  36. #include "net/spdy/spdy_test_util_common.h"
  37. #include "net/ssl/ssl_cert_request_info.h"
  38. #include "net/test/cert_test_util.h"
  39. #include "net/test/gtest_util.h"
  40. #include "net/test/test_data_directory.h"
  41. #include "net/test/test_with_task_environment.h"
  42. #include "net/url_request/url_request_test_util.h"
  43. #include "testing/gmock/include/gmock/gmock.h"
  44. #include "testing/gtest/include/gtest/gtest.h"
  45. using net::test::IsError;
  46. using net::test::IsOk;
  47. namespace net {
  48. namespace {
  49. const char kBodyData[] = "Body data";
  50. const size_t kBodyDataSize = std::size(kBodyData);
  51. const std::string kBodyDataString(kBodyData, kBodyDataSize);
  52. // Size of the buffer to be allocated for each read.
  53. const size_t kReadBufferSize = 4096;
  54. // Expects that fields of |load_timing_info| are valid time stamps.
  55. void ExpectLoadTimingValid(const LoadTimingInfo& load_timing_info) {
  56. EXPECT_FALSE(load_timing_info.request_start.is_null());
  57. EXPECT_FALSE(load_timing_info.request_start_time.is_null());
  58. EXPECT_FALSE(load_timing_info.receive_headers_end.is_null());
  59. EXPECT_FALSE(load_timing_info.send_start.is_null());
  60. EXPECT_FALSE(load_timing_info.send_end.is_null());
  61. EXPECT_TRUE(load_timing_info.request_start <=
  62. load_timing_info.receive_headers_end);
  63. EXPECT_TRUE(load_timing_info.send_start <= load_timing_info.send_end);
  64. }
  65. // Tests the load timing of a stream that's connected and is not the first
  66. // request sent on a connection.
  67. void TestLoadTimingReused(const LoadTimingInfo& load_timing_info) {
  68. EXPECT_TRUE(load_timing_info.socket_reused);
  69. ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
  70. ExpectLoadTimingValid(load_timing_info);
  71. }
  72. // Tests the load timing of a stream that's connected and using a fresh
  73. // connection.
  74. void TestLoadTimingNotReused(const LoadTimingInfo& load_timing_info) {
  75. EXPECT_FALSE(load_timing_info.socket_reused);
  76. ExpectConnectTimingHasTimes(
  77. load_timing_info.connect_timing,
  78. CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
  79. ExpectLoadTimingValid(load_timing_info);
  80. }
  81. // Delegate that reads data but does not send any data.
  82. class TestDelegateBase : public BidirectionalStream::Delegate {
  83. public:
  84. TestDelegateBase(IOBuffer* read_buf, int read_buf_len)
  85. : TestDelegateBase(read_buf,
  86. read_buf_len,
  87. std::make_unique<base::OneShotTimer>()) {}
  88. TestDelegateBase(IOBuffer* read_buf,
  89. int read_buf_len,
  90. std::unique_ptr<base::OneShotTimer> timer)
  91. : read_buf_(read_buf),
  92. read_buf_len_(read_buf_len),
  93. timer_(std::move(timer)) {}
  94. TestDelegateBase(const TestDelegateBase&) = delete;
  95. TestDelegateBase& operator=(const TestDelegateBase&) = delete;
  96. ~TestDelegateBase() override = default;
  97. void OnStreamReady(bool request_headers_sent) override {
  98. // Request headers should always be sent in H2's case, because the
  99. // functionality to combine header frame with data frames is not
  100. // implemented.
  101. EXPECT_TRUE(request_headers_sent);
  102. if (callback_.is_null())
  103. return;
  104. std::move(callback_).Run(OK);
  105. }
  106. void OnHeadersReceived(
  107. const spdy::Http2HeaderBlock& response_headers) override {
  108. CHECK(!not_expect_callback_);
  109. response_headers_ = response_headers.Clone();
  110. if (!do_not_start_read_)
  111. StartOrContinueReading();
  112. }
  113. void OnDataRead(int bytes_read) override {
  114. CHECK(!not_expect_callback_);
  115. ++on_data_read_count_;
  116. CHECK_GE(bytes_read, OK);
  117. data_received_.append(read_buf_->data(), bytes_read);
  118. if (!do_not_start_read_)
  119. StartOrContinueReading();
  120. }
  121. void OnDataSent() override {
  122. CHECK(!not_expect_callback_);
  123. ++on_data_sent_count_;
  124. }
  125. void OnTrailersReceived(const spdy::Http2HeaderBlock& trailers) override {
  126. CHECK(!not_expect_callback_);
  127. trailers_ = trailers.Clone();
  128. if (run_until_completion_)
  129. loop_->Quit();
  130. }
  131. void OnFailed(int error) override {
  132. CHECK(!not_expect_callback_);
  133. CHECK_EQ(OK, error_);
  134. CHECK_NE(OK, error);
  135. error_ = error;
  136. if (run_until_completion_)
  137. loop_->Quit();
  138. }
  139. void Start(std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
  140. HttpNetworkSession* session) {
  141. stream_ = std::make_unique<BidirectionalStream>(
  142. std::move(request_info), session, true, this, std::move(timer_));
  143. if (run_until_completion_)
  144. loop_->Run();
  145. }
  146. void Start(std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
  147. HttpNetworkSession* session,
  148. CompletionOnceCallback cb) {
  149. callback_ = std::move(cb);
  150. stream_ = std::make_unique<BidirectionalStream>(
  151. std::move(request_info), session, true, this, std::move(timer_));
  152. if (run_until_completion_)
  153. WaitUntilCompletion();
  154. }
  155. void WaitUntilCompletion() { loop_->Run(); }
  156. void SendData(const scoped_refptr<IOBuffer>& data,
  157. int length,
  158. bool end_of_stream) {
  159. SendvData({data}, {length}, end_of_stream);
  160. }
  161. void SendvData(const std::vector<scoped_refptr<IOBuffer>>& data,
  162. const std::vector<int>& length,
  163. bool end_of_stream) {
  164. not_expect_callback_ = true;
  165. stream_->SendvData(data, length, end_of_stream);
  166. not_expect_callback_ = false;
  167. }
  168. // Starts or continues reading data from |stream_| until no more bytes
  169. // can be read synchronously.
  170. void StartOrContinueReading() {
  171. int rv = ReadData();
  172. while (rv > 0) {
  173. rv = ReadData();
  174. }
  175. if (run_until_completion_ && rv == 0)
  176. loop_->Quit();
  177. }
  178. // Calls ReadData on the |stream_| and updates internal states.
  179. int ReadData() {
  180. not_expect_callback_ = true;
  181. int rv = stream_->ReadData(read_buf_.get(), read_buf_len_);
  182. not_expect_callback_ = false;
  183. if (rv > 0)
  184. data_received_.append(read_buf_->data(), rv);
  185. return rv;
  186. }
  187. // Deletes |stream_|.
  188. void DeleteStream() {
  189. next_proto_ = stream_->GetProtocol();
  190. received_bytes_ = stream_->GetTotalReceivedBytes();
  191. sent_bytes_ = stream_->GetTotalSentBytes();
  192. stream_->GetLoadTimingInfo(&load_timing_info_);
  193. stream_.reset();
  194. }
  195. NextProto GetProtocol() const {
  196. if (stream_)
  197. return stream_->GetProtocol();
  198. return next_proto_;
  199. }
  200. int64_t GetTotalReceivedBytes() const {
  201. if (stream_)
  202. return stream_->GetTotalReceivedBytes();
  203. return received_bytes_;
  204. }
  205. int64_t GetTotalSentBytes() const {
  206. if (stream_)
  207. return stream_->GetTotalSentBytes();
  208. return sent_bytes_;
  209. }
  210. void GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
  211. if (stream_) {
  212. stream_->GetLoadTimingInfo(load_timing_info);
  213. return;
  214. }
  215. *load_timing_info = load_timing_info_;
  216. }
  217. // Const getters for internal states.
  218. const std::string& data_received() const { return data_received_; }
  219. int error() const { return error_; }
  220. const spdy::Http2HeaderBlock& response_headers() const {
  221. return response_headers_;
  222. }
  223. const spdy::Http2HeaderBlock& trailers() const { return trailers_; }
  224. int on_data_read_count() const { return on_data_read_count_; }
  225. int on_data_sent_count() const { return on_data_sent_count_; }
  226. // Sets whether the delegate should automatically start reading.
  227. void set_do_not_start_read(bool do_not_start_read) {
  228. do_not_start_read_ = do_not_start_read;
  229. }
  230. // Sets whether the delegate should wait until the completion of the stream.
  231. void SetRunUntilCompletion(bool run_until_completion) {
  232. run_until_completion_ = run_until_completion;
  233. loop_ = std::make_unique<base::RunLoop>();
  234. }
  235. protected:
  236. // Quits |loop_|.
  237. void QuitLoop() { loop_->Quit(); }
  238. private:
  239. std::unique_ptr<BidirectionalStream> stream_;
  240. scoped_refptr<IOBuffer> read_buf_;
  241. int read_buf_len_;
  242. std::unique_ptr<base::OneShotTimer> timer_;
  243. std::string data_received_;
  244. std::unique_ptr<base::RunLoop> loop_;
  245. spdy::Http2HeaderBlock response_headers_;
  246. spdy::Http2HeaderBlock trailers_;
  247. NextProto next_proto_;
  248. int64_t received_bytes_ = 0;
  249. int64_t sent_bytes_ = 0;
  250. LoadTimingInfo load_timing_info_;
  251. int error_ = OK;
  252. int on_data_read_count_ = 0;
  253. int on_data_sent_count_ = 0;
  254. bool do_not_start_read_ = false;
  255. bool run_until_completion_ = false;
  256. // This is to ensure that delegate callback is not invoked synchronously when
  257. // calling into |stream_|.
  258. bool not_expect_callback_ = false;
  259. CompletionOnceCallback callback_;
  260. };
  261. // A delegate that deletes the stream in a particular callback.
  262. class DeleteStreamDelegate : public TestDelegateBase {
  263. public:
  264. // Specifies in which callback the stream can be deleted.
  265. enum Phase {
  266. ON_HEADERS_RECEIVED,
  267. ON_DATA_READ,
  268. ON_TRAILERS_RECEIVED,
  269. ON_FAILED,
  270. };
  271. DeleteStreamDelegate(IOBuffer* buf, int buf_len, Phase phase)
  272. : TestDelegateBase(buf, buf_len), phase_(phase) {}
  273. DeleteStreamDelegate(const DeleteStreamDelegate&) = delete;
  274. DeleteStreamDelegate& operator=(const DeleteStreamDelegate&) = delete;
  275. ~DeleteStreamDelegate() override = default;
  276. void OnHeadersReceived(
  277. const spdy::Http2HeaderBlock& response_headers) override {
  278. TestDelegateBase::OnHeadersReceived(response_headers);
  279. if (phase_ == ON_HEADERS_RECEIVED) {
  280. DeleteStream();
  281. QuitLoop();
  282. }
  283. }
  284. void OnDataSent() override { NOTREACHED(); }
  285. void OnDataRead(int bytes_read) override {
  286. if (phase_ == ON_HEADERS_RECEIVED) {
  287. NOTREACHED();
  288. return;
  289. }
  290. TestDelegateBase::OnDataRead(bytes_read);
  291. if (phase_ == ON_DATA_READ) {
  292. DeleteStream();
  293. QuitLoop();
  294. }
  295. }
  296. void OnTrailersReceived(const spdy::Http2HeaderBlock& trailers) override {
  297. if (phase_ == ON_HEADERS_RECEIVED || phase_ == ON_DATA_READ) {
  298. NOTREACHED();
  299. return;
  300. }
  301. TestDelegateBase::OnTrailersReceived(trailers);
  302. if (phase_ == ON_TRAILERS_RECEIVED) {
  303. DeleteStream();
  304. QuitLoop();
  305. }
  306. }
  307. void OnFailed(int error) override {
  308. if (phase_ != ON_FAILED) {
  309. NOTREACHED();
  310. return;
  311. }
  312. TestDelegateBase::OnFailed(error);
  313. DeleteStream();
  314. QuitLoop();
  315. }
  316. private:
  317. // Indicates in which callback the delegate should cancel or delete the
  318. // stream.
  319. Phase phase_;
  320. };
  321. // A Timer that does not start a delayed task unless the timer is fired.
  322. class MockTimer : public base::MockOneShotTimer {
  323. public:
  324. MockTimer() = default;
  325. MockTimer(const MockTimer&) = delete;
  326. MockTimer& operator=(const MockTimer&) = delete;
  327. ~MockTimer() override = default;
  328. void Start(const base::Location& posted_from,
  329. base::TimeDelta delay,
  330. base::OnceClosure user_task) override {
  331. // Sets a maximum delay, so the timer does not fire unless it is told to.
  332. base::TimeDelta infinite_delay = base::TimeDelta::Max();
  333. base::MockOneShotTimer::Start(posted_from, infinite_delay,
  334. std::move(user_task));
  335. }
  336. };
  337. } // namespace
  338. class BidirectionalStreamTest : public TestWithTaskEnvironment {
  339. public:
  340. BidirectionalStreamTest()
  341. : default_url_(kDefaultUrl),
  342. host_port_pair_(HostPortPair::FromURL(default_url_)),
  343. ssl_data_(SSLSocketDataProvider(ASYNC, OK)) {
  344. ssl_data_.next_proto = kProtoHTTP2;
  345. ssl_data_.ssl_info.cert =
  346. ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
  347. net_log_observer_.SetObserverCaptureMode(NetLogCaptureMode::kEverything);
  348. auto socket_factory = std::make_unique<MockTaggingClientSocketFactory>();
  349. socket_factory_ = socket_factory.get();
  350. session_deps_.socket_factory = std::move(socket_factory);
  351. }
  352. protected:
  353. void TearDown() override {
  354. if (sequenced_data_) {
  355. EXPECT_TRUE(sequenced_data_->AllReadDataConsumed());
  356. EXPECT_TRUE(sequenced_data_->AllWriteDataConsumed());
  357. }
  358. }
  359. // Initializes the session using SequencedSocketData.
  360. void InitSession(base::span<const MockRead> reads,
  361. base::span<const MockWrite> writes,
  362. const SocketTag& socket_tag) {
  363. ASSERT_TRUE(ssl_data_.ssl_info.cert.get());
  364. session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data_);
  365. sequenced_data_ = std::make_unique<SequencedSocketData>(reads, writes);
  366. session_deps_.socket_factory->AddSocketDataProvider(sequenced_data_.get());
  367. session_deps_.net_log = NetLog::Get();
  368. http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
  369. SpdySessionKey key(host_port_pair_, ProxyServer::Direct(),
  370. PRIVACY_MODE_DISABLED,
  371. SpdySessionKey::IsProxySession::kFalse, socket_tag,
  372. NetworkIsolationKey(), SecureDnsPolicy::kAllow);
  373. session_ =
  374. CreateSpdySession(http_session_.get(), key,
  375. NetLogWithSource::Make(NetLogSourceType::NONE));
  376. }
  377. RecordingNetLogObserver net_log_observer_;
  378. SpdyTestUtil spdy_util_;
  379. SpdySessionDependencies session_deps_;
  380. const GURL default_url_;
  381. const HostPortPair host_port_pair_;
  382. std::unique_ptr<SequencedSocketData> sequenced_data_;
  383. std::unique_ptr<HttpNetworkSession> http_session_;
  384. raw_ptr<MockTaggingClientSocketFactory> socket_factory_;
  385. private:
  386. SSLSocketDataProvider ssl_data_;
  387. base::WeakPtr<SpdySession> session_;
  388. };
  389. TEST_F(BidirectionalStreamTest, CreateInsecureStream) {
  390. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  391. request_info->method = "GET";
  392. request_info->url = GURL("http://www.example.org/");
  393. TestDelegateBase delegate(nullptr, 0);
  394. auto session = std::make_unique<HttpNetworkSession>(
  395. SpdySessionDependencies::CreateSessionParams(&session_deps_),
  396. SpdySessionDependencies::CreateSessionContext(&session_deps_));
  397. delegate.SetRunUntilCompletion(true);
  398. delegate.Start(std::move(request_info), session.get());
  399. EXPECT_THAT(delegate.error(), IsError(ERR_DISALLOWED_URL_SCHEME));
  400. }
  401. TEST_F(BidirectionalStreamTest, SimplePostRequest) {
  402. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  403. kDefaultUrl, 1, kBodyDataSize, LOW, nullptr, 0));
  404. spdy::SpdySerializedFrame data_frame(
  405. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/true));
  406. MockWrite writes[] = {
  407. CreateMockWrite(req, 0), CreateMockWrite(data_frame, 3),
  408. };
  409. spdy::SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostReply(nullptr, 0));
  410. spdy::SpdySerializedFrame response_body_frame(
  411. spdy_util_.ConstructSpdyDataFrame(1, /*fin=*/true));
  412. MockRead reads[] = {
  413. CreateMockRead(resp, 1),
  414. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  415. CreateMockRead(response_body_frame, 4), MockRead(ASYNC, 0, 5),
  416. };
  417. InitSession(reads, writes, SocketTag());
  418. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  419. request_info->method = "POST";
  420. request_info->url = default_url_;
  421. request_info->extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
  422. base::NumberToString(kBodyDataSize));
  423. scoped_refptr<IOBuffer> read_buffer =
  424. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  425. auto delegate =
  426. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  427. delegate->Start(std::move(request_info), http_session_.get());
  428. sequenced_data_->RunUntilPaused();
  429. scoped_refptr<StringIOBuffer> buf =
  430. base::MakeRefCounted<StringIOBuffer>(kBodyDataString);
  431. delegate->SendData(buf.get(), buf->size(), true);
  432. sequenced_data_->Resume();
  433. base::RunLoop().RunUntilIdle();
  434. LoadTimingInfo load_timing_info;
  435. delegate->GetLoadTimingInfo(&load_timing_info);
  436. TestLoadTimingNotReused(load_timing_info);
  437. EXPECT_EQ(1, delegate->on_data_read_count());
  438. EXPECT_EQ(1, delegate->on_data_sent_count());
  439. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  440. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  441. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  442. }
  443. TEST_F(BidirectionalStreamTest, LoadTimingTwoRequests) {
  444. spdy::SpdySerializedFrame req(
  445. spdy_util_.ConstructSpdyGet(nullptr, 0, /*stream_id=*/1, LOW));
  446. spdy::SpdySerializedFrame req2(
  447. spdy_util_.ConstructSpdyGet(nullptr, 0, /*stream_id=*/3, LOW));
  448. MockWrite writes[] = {
  449. CreateMockWrite(req, 0), CreateMockWrite(req2, 2),
  450. };
  451. spdy::SpdySerializedFrame resp(
  452. spdy_util_.ConstructSpdyGetReply(nullptr, 0, /*stream_id=*/1));
  453. spdy::SpdySerializedFrame resp2(
  454. spdy_util_.ConstructSpdyGetReply(nullptr, 0, /*stream_id=*/3));
  455. spdy::SpdySerializedFrame resp_body(
  456. spdy_util_.ConstructSpdyDataFrame(/*stream_id=*/1, /*fin=*/true));
  457. spdy::SpdySerializedFrame resp_body2(
  458. spdy_util_.ConstructSpdyDataFrame(/*stream_id=*/3, /*fin=*/true));
  459. MockRead reads[] = {CreateMockRead(resp, 1), CreateMockRead(resp_body, 3),
  460. CreateMockRead(resp2, 4), CreateMockRead(resp_body2, 5),
  461. MockRead(ASYNC, 0, 6)};
  462. InitSession(reads, writes, SocketTag());
  463. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  464. request_info->method = "GET";
  465. request_info->url = default_url_;
  466. request_info->end_stream_on_headers = true;
  467. auto request_info2 = std::make_unique<BidirectionalStreamRequestInfo>();
  468. request_info2->method = "GET";
  469. request_info2->url = default_url_;
  470. request_info2->end_stream_on_headers = true;
  471. scoped_refptr<IOBuffer> read_buffer =
  472. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  473. scoped_refptr<IOBuffer> read_buffer2 =
  474. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  475. auto delegate =
  476. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  477. auto delegate2 =
  478. std::make_unique<TestDelegateBase>(read_buffer2.get(), kReadBufferSize);
  479. delegate->Start(std::move(request_info), http_session_.get());
  480. delegate2->Start(std::move(request_info2), http_session_.get());
  481. delegate->SetRunUntilCompletion(true);
  482. delegate2->SetRunUntilCompletion(true);
  483. base::RunLoop().RunUntilIdle();
  484. delegate->WaitUntilCompletion();
  485. delegate2->WaitUntilCompletion();
  486. LoadTimingInfo load_timing_info;
  487. delegate->GetLoadTimingInfo(&load_timing_info);
  488. TestLoadTimingNotReused(load_timing_info);
  489. LoadTimingInfo load_timing_info2;
  490. delegate2->GetLoadTimingInfo(&load_timing_info2);
  491. TestLoadTimingReused(load_timing_info2);
  492. }
  493. // Creates a BidirectionalStream with an insecure scheme. Destroy the stream
  494. // without waiting for the OnFailed task to be executed.
  495. TEST_F(BidirectionalStreamTest,
  496. CreateInsecureStreamAndDestroyStreamRightAfter) {
  497. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  498. request_info->method = "GET";
  499. request_info->url = GURL("http://www.example.org/");
  500. auto delegate = std::make_unique<TestDelegateBase>(nullptr, 0);
  501. auto session = std::make_unique<HttpNetworkSession>(
  502. SpdySessionDependencies::CreateSessionParams(&session_deps_),
  503. SpdySessionDependencies::CreateSessionContext(&session_deps_));
  504. delegate->Start(std::move(request_info), session.get());
  505. // Reset stream right before the OnFailed task is executed.
  506. delegate.reset();
  507. base::RunLoop().RunUntilIdle();
  508. }
  509. TEST_F(BidirectionalStreamTest, ClientAuthRequestIgnored) {
  510. auto cert_request = base::MakeRefCounted<SSLCertRequestInfo>();
  511. cert_request->host_and_port = host_port_pair_;
  512. // First attempt receives client auth request.
  513. SSLSocketDataProvider ssl_data1(ASYNC, ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
  514. ssl_data1.next_proto = kProtoHTTP2;
  515. ssl_data1.cert_request_info = cert_request.get();
  516. session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data1);
  517. StaticSocketDataProvider socket_data1;
  518. session_deps_.socket_factory->AddSocketDataProvider(&socket_data1);
  519. // Second attempt succeeds.
  520. spdy::SpdySerializedFrame req(
  521. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  522. MockWrite writes[] = {
  523. CreateMockWrite(req, 0),
  524. };
  525. spdy::SpdySerializedFrame resp(
  526. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  527. spdy::SpdySerializedFrame body_frame(
  528. spdy_util_.ConstructSpdyDataFrame(1, true));
  529. MockRead reads[] = {
  530. CreateMockRead(resp, 1), CreateMockRead(body_frame, 2),
  531. MockRead(SYNCHRONOUS, net::OK, 3),
  532. };
  533. SSLSocketDataProvider ssl_data2(ASYNC, OK);
  534. ssl_data2.next_proto = kProtoHTTP2;
  535. session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data2);
  536. SequencedSocketData socket_data2(reads, writes);
  537. session_deps_.socket_factory->AddSocketDataProvider(&socket_data2);
  538. http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
  539. SpdySessionKey key(host_port_pair_, ProxyServer::Direct(),
  540. PRIVACY_MODE_DISABLED,
  541. SpdySessionKey::IsProxySession::kFalse, SocketTag(),
  542. NetworkIsolationKey(), SecureDnsPolicy::kAllow);
  543. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  544. request_info->method = "GET";
  545. request_info->url = default_url_;
  546. request_info->end_stream_on_headers = true;
  547. request_info->priority = LOWEST;
  548. scoped_refptr<IOBuffer> read_buffer =
  549. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  550. auto delegate =
  551. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  552. delegate->SetRunUntilCompletion(true);
  553. delegate->Start(std::move(request_info), http_session_.get());
  554. // Ensure the certificate was added to the client auth cache.
  555. scoped_refptr<X509Certificate> client_cert;
  556. scoped_refptr<SSLPrivateKey> client_private_key;
  557. ASSERT_TRUE(http_session_->ssl_client_context()->GetClientCertificate(
  558. host_port_pair_, &client_cert, &client_private_key));
  559. ASSERT_FALSE(client_cert);
  560. ASSERT_FALSE(client_private_key);
  561. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  562. EXPECT_EQ("200", response_headers.find(":status")->second);
  563. EXPECT_EQ(1, delegate->on_data_read_count());
  564. EXPECT_EQ(0, delegate->on_data_sent_count());
  565. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  566. }
  567. // Simulates user calling ReadData after END_STREAM has been received in
  568. // BidirectionalStreamSpdyImpl.
  569. TEST_F(BidirectionalStreamTest, TestReadDataAfterClose) {
  570. spdy::SpdySerializedFrame req(
  571. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  572. MockWrite writes[] = {
  573. CreateMockWrite(req, 0),
  574. };
  575. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  576. spdy::SpdySerializedFrame resp(
  577. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  578. spdy::SpdySerializedFrame body_frame(
  579. spdy_util_.ConstructSpdyDataFrame(1, false));
  580. // Last body frame has END_STREAM flag set.
  581. spdy::SpdySerializedFrame last_body_frame(
  582. spdy_util_.ConstructSpdyDataFrame(1, true));
  583. MockRead reads[] = {
  584. CreateMockRead(resp, 1),
  585. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  586. CreateMockRead(body_frame, 3),
  587. MockRead(ASYNC, ERR_IO_PENDING, 4), // Force a pause.
  588. CreateMockRead(body_frame, 5),
  589. CreateMockRead(last_body_frame, 6),
  590. MockRead(SYNCHRONOUS, 0, 7),
  591. };
  592. InitSession(reads, writes, SocketTag());
  593. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  594. request_info->method = "GET";
  595. request_info->url = default_url_;
  596. request_info->end_stream_on_headers = true;
  597. request_info->priority = LOWEST;
  598. scoped_refptr<IOBuffer> read_buffer =
  599. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  600. // Create a MockTimer. Retain a raw pointer since the underlying
  601. // BidirectionalStreamImpl owns it.
  602. auto timer = std::make_unique<MockTimer>();
  603. MockTimer* timer_ptr = timer.get();
  604. auto delegate = std::make_unique<TestDelegateBase>(
  605. read_buffer.get(), kReadBufferSize, std::move(timer));
  606. delegate->set_do_not_start_read(true);
  607. delegate->Start(std::move(request_info), http_session_.get());
  608. // Write request, and deliver response headers.
  609. sequenced_data_->RunUntilPaused();
  610. EXPECT_FALSE(timer_ptr->IsRunning());
  611. // ReadData returns asynchronously because no data is buffered.
  612. int rv = delegate->ReadData();
  613. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  614. // Deliver a DATA frame.
  615. sequenced_data_->Resume();
  616. base::RunLoop().RunUntilIdle();
  617. timer_ptr->Fire();
  618. // Asynchronous completion callback is invoke.
  619. EXPECT_EQ(1, delegate->on_data_read_count());
  620. EXPECT_EQ(kUploadDataSize * 1,
  621. static_cast<int>(delegate->data_received().size()));
  622. // Deliver the rest. Note that user has not called a second ReadData.
  623. sequenced_data_->Resume();
  624. base::RunLoop().RunUntilIdle();
  625. // ReadData now. Read should complete synchronously.
  626. rv = delegate->ReadData();
  627. EXPECT_EQ(kUploadDataSize * 2, rv);
  628. rv = delegate->ReadData();
  629. EXPECT_THAT(rv, IsOk()); // EOF.
  630. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  631. EXPECT_EQ("200", response_headers.find(":status")->second);
  632. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  633. EXPECT_EQ(1, delegate->on_data_read_count());
  634. EXPECT_EQ(0, delegate->on_data_sent_count());
  635. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  636. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  637. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  638. }
  639. // Tests that the NetLog contains correct entries.
  640. TEST_F(BidirectionalStreamTest, TestNetLogContainEntries) {
  641. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  642. kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
  643. spdy::SpdySerializedFrame data_frame(
  644. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/true));
  645. MockWrite writes[] = {
  646. CreateMockWrite(req, 0), CreateMockWrite(data_frame, 3),
  647. };
  648. spdy::SpdySerializedFrame resp(
  649. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  650. spdy::SpdySerializedFrame response_body_frame1(
  651. spdy_util_.ConstructSpdyDataFrame(1, false));
  652. spdy::SpdySerializedFrame response_body_frame2(
  653. spdy_util_.ConstructSpdyDataFrame(1, false));
  654. spdy::Http2HeaderBlock trailers;
  655. trailers["foo"] = "bar";
  656. spdy::SpdySerializedFrame response_trailers(
  657. spdy_util_.ConstructSpdyResponseHeaders(1, std::move(trailers), true));
  658. MockRead reads[] = {
  659. CreateMockRead(resp, 1),
  660. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  661. CreateMockRead(response_body_frame1, 4),
  662. MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause.
  663. CreateMockRead(response_body_frame2, 6),
  664. CreateMockRead(response_trailers, 7),
  665. MockRead(ASYNC, 0, 8),
  666. };
  667. InitSession(reads, writes, SocketTag());
  668. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  669. request_info->method = "POST";
  670. request_info->url = default_url_;
  671. request_info->priority = LOWEST;
  672. request_info->extra_headers.SetHeader(
  673. net::HttpRequestHeaders::kContentLength,
  674. base::NumberToString(kBodyDataSize * 3));
  675. scoped_refptr<IOBuffer> read_buffer =
  676. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  677. auto timer = std::make_unique<MockTimer>();
  678. MockTimer* timer_ptr = timer.get();
  679. auto delegate = std::make_unique<TestDelegateBase>(
  680. read_buffer.get(), kReadBufferSize, std::move(timer));
  681. delegate->set_do_not_start_read(true);
  682. delegate->Start(std::move(request_info), http_session_.get());
  683. // Send the request and receive response headers.
  684. sequenced_data_->RunUntilPaused();
  685. EXPECT_FALSE(timer_ptr->IsRunning());
  686. scoped_refptr<StringIOBuffer> buf =
  687. base::MakeRefCounted<StringIOBuffer>(kBodyDataString);
  688. // Send a DATA frame.
  689. delegate->SendData(buf, buf->size(), true);
  690. // ReadData returns asynchronously because no data is buffered.
  691. int rv = delegate->ReadData();
  692. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  693. // Deliver the first DATA frame.
  694. sequenced_data_->Resume();
  695. sequenced_data_->RunUntilPaused();
  696. // |sequenced_data_| is now stopped after delivering first DATA frame but
  697. // before the second DATA frame.
  698. // Fire the timer to allow the first ReadData to complete asynchronously.
  699. timer_ptr->Fire();
  700. base::RunLoop().RunUntilIdle();
  701. EXPECT_EQ(1, delegate->on_data_read_count());
  702. // Now let |sequenced_data_| run until completion.
  703. sequenced_data_->Resume();
  704. base::RunLoop().RunUntilIdle();
  705. // All data has been delivered, and OnClosed() has been invoked.
  706. // Read now, and it should complete synchronously.
  707. rv = delegate->ReadData();
  708. EXPECT_EQ(kUploadDataSize, rv);
  709. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  710. EXPECT_EQ(1, delegate->on_data_read_count());
  711. EXPECT_EQ(1, delegate->on_data_sent_count());
  712. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  713. EXPECT_EQ("bar", delegate->trailers().find("foo")->second);
  714. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  715. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  716. // Destroy the delegate will destroy the stream, so we can get an end event
  717. // for BIDIRECTIONAL_STREAM_ALIVE.
  718. delegate.reset();
  719. auto entries = net_log_observer_.GetEntries();
  720. size_t index = ExpectLogContainsSomewhere(
  721. entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_ALIVE,
  722. NetLogEventPhase::BEGIN);
  723. // HTTP_STREAM_REQUEST is nested inside in BIDIRECTIONAL_STREAM_ALIVE.
  724. index = ExpectLogContainsSomewhere(entries, index,
  725. NetLogEventType::HTTP_STREAM_REQUEST,
  726. NetLogEventPhase::BEGIN);
  727. index = ExpectLogContainsSomewhere(entries, index,
  728. NetLogEventType::HTTP_STREAM_REQUEST,
  729. NetLogEventPhase::END);
  730. // Headers received should happen after HTTP_STREAM_REQUEST.
  731. index = ExpectLogContainsSomewhere(
  732. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_RECV_HEADERS,
  733. NetLogEventPhase::NONE);
  734. // Trailers received should happen after headers received. It might happen
  735. // before the reads complete.
  736. ExpectLogContainsSomewhere(
  737. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_RECV_TRAILERS,
  738. NetLogEventPhase::NONE);
  739. index = ExpectLogContainsSomewhere(
  740. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_SENDV_DATA,
  741. NetLogEventPhase::NONE);
  742. index = ExpectLogContainsSomewhere(
  743. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_READ_DATA,
  744. NetLogEventPhase::NONE);
  745. EXPECT_EQ(ERR_IO_PENDING, GetIntegerValueFromParams(entries[index], "rv"));
  746. // Sent bytes. Sending data is always asynchronous.
  747. index = ExpectLogContainsSomewhere(
  748. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
  749. NetLogEventPhase::NONE);
  750. EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entries[index].source.type);
  751. // Received bytes for asynchronous read.
  752. index = ExpectLogContainsSomewhere(
  753. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
  754. NetLogEventPhase::NONE);
  755. EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entries[index].source.type);
  756. // Received bytes for synchronous read.
  757. index = ExpectLogContainsSomewhere(
  758. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_RECEIVED,
  759. NetLogEventPhase::NONE);
  760. EXPECT_EQ(NetLogSourceType::BIDIRECTIONAL_STREAM, entries[index].source.type);
  761. ExpectLogContainsSomewhere(entries, index,
  762. NetLogEventType::BIDIRECTIONAL_STREAM_ALIVE,
  763. NetLogEventPhase::END);
  764. }
  765. TEST_F(BidirectionalStreamTest, TestInterleaveReadDataAndSendData) {
  766. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  767. kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
  768. spdy::SpdySerializedFrame data_frame1(
  769. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/false));
  770. spdy::SpdySerializedFrame data_frame2(
  771. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/false));
  772. spdy::SpdySerializedFrame data_frame3(
  773. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/true));
  774. MockWrite writes[] = {
  775. CreateMockWrite(req, 0), CreateMockWrite(data_frame1, 3),
  776. CreateMockWrite(data_frame2, 6), CreateMockWrite(data_frame3, 9),
  777. };
  778. spdy::SpdySerializedFrame resp(
  779. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  780. spdy::SpdySerializedFrame response_body_frame1(
  781. spdy_util_.ConstructSpdyDataFrame(1, false));
  782. spdy::SpdySerializedFrame response_body_frame2(
  783. spdy_util_.ConstructSpdyDataFrame(1, true));
  784. MockRead reads[] = {
  785. CreateMockRead(resp, 1),
  786. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  787. CreateMockRead(response_body_frame1, 4),
  788. MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause.
  789. CreateMockRead(response_body_frame2, 7),
  790. MockRead(ASYNC, ERR_IO_PENDING, 8), // Force a pause.
  791. MockRead(ASYNC, 0, 10),
  792. };
  793. InitSession(reads, writes, SocketTag());
  794. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  795. request_info->method = "POST";
  796. request_info->url = default_url_;
  797. request_info->priority = LOWEST;
  798. request_info->extra_headers.SetHeader(
  799. net::HttpRequestHeaders::kContentLength,
  800. base::NumberToString(kBodyDataSize * 3));
  801. scoped_refptr<IOBuffer> read_buffer =
  802. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  803. auto timer = std::make_unique<MockTimer>();
  804. MockTimer* timer_ptr = timer.get();
  805. auto delegate = std::make_unique<TestDelegateBase>(
  806. read_buffer.get(), kReadBufferSize, std::move(timer));
  807. delegate->set_do_not_start_read(true);
  808. delegate->Start(std::move(request_info), http_session_.get());
  809. // Send the request and receive response headers.
  810. sequenced_data_->RunUntilPaused();
  811. EXPECT_FALSE(timer_ptr->IsRunning());
  812. // Send a DATA frame.
  813. scoped_refptr<StringIOBuffer> buf =
  814. base::MakeRefCounted<StringIOBuffer>(kBodyDataString);
  815. // Send a DATA frame.
  816. delegate->SendData(buf, buf->size(), false);
  817. // ReadData and it should return asynchronously because no data is buffered.
  818. int rv = delegate->ReadData();
  819. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  820. // Deliver a DATA frame, and fire the timer.
  821. sequenced_data_->Resume();
  822. sequenced_data_->RunUntilPaused();
  823. timer_ptr->Fire();
  824. base::RunLoop().RunUntilIdle();
  825. EXPECT_EQ(1, delegate->on_data_sent_count());
  826. EXPECT_EQ(1, delegate->on_data_read_count());
  827. // Send a DATA frame.
  828. delegate->SendData(buf, buf->size(), false);
  829. // ReadData and it should return asynchronously because no data is buffered.
  830. rv = delegate->ReadData();
  831. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  832. // Deliver a DATA frame, and fire the timer.
  833. sequenced_data_->Resume();
  834. sequenced_data_->RunUntilPaused();
  835. timer_ptr->Fire();
  836. base::RunLoop().RunUntilIdle();
  837. // Last DATA frame is read. Server half closes.
  838. EXPECT_EQ(2, delegate->on_data_read_count());
  839. EXPECT_EQ(2, delegate->on_data_sent_count());
  840. // Send the last body frame. Client half closes.
  841. delegate->SendData(buf, buf->size(), true);
  842. sequenced_data_->Resume();
  843. base::RunLoop().RunUntilIdle();
  844. EXPECT_EQ(3, delegate->on_data_sent_count());
  845. // OnClose is invoked since both sides are closed.
  846. rv = delegate->ReadData();
  847. EXPECT_THAT(rv, IsOk());
  848. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  849. EXPECT_EQ(2, delegate->on_data_read_count());
  850. EXPECT_EQ(3, delegate->on_data_sent_count());
  851. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  852. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  853. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  854. }
  855. TEST_F(BidirectionalStreamTest, TestCoalesceSmallDataBuffers) {
  856. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  857. kDefaultUrl, 1, kBodyDataSize * 1, LOWEST, nullptr, 0));
  858. std::string body_data = "some really long piece of data";
  859. spdy::SpdySerializedFrame data_frame1(
  860. spdy_util_.ConstructSpdyDataFrame(1, body_data, /*fin=*/true));
  861. MockWrite writes[] = {
  862. CreateMockWrite(req, 0), CreateMockWrite(data_frame1, 1),
  863. };
  864. spdy::SpdySerializedFrame resp(
  865. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  866. spdy::SpdySerializedFrame response_body_frame1(
  867. spdy_util_.ConstructSpdyDataFrame(1, true));
  868. MockRead reads[] = {
  869. CreateMockRead(resp, 2),
  870. MockRead(ASYNC, ERR_IO_PENDING, 3), // Force a pause.
  871. CreateMockRead(response_body_frame1, 4), MockRead(ASYNC, 0, 5),
  872. };
  873. InitSession(reads, writes, SocketTag());
  874. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  875. request_info->method = "POST";
  876. request_info->url = default_url_;
  877. request_info->priority = LOWEST;
  878. request_info->extra_headers.SetHeader(
  879. net::HttpRequestHeaders::kContentLength,
  880. base::NumberToString(kBodyDataSize * 1));
  881. scoped_refptr<IOBuffer> read_buffer =
  882. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  883. auto timer = std::make_unique<MockTimer>();
  884. auto delegate = std::make_unique<TestDelegateBase>(
  885. read_buffer.get(), kReadBufferSize, std::move(timer));
  886. delegate->set_do_not_start_read(true);
  887. TestCompletionCallback callback;
  888. delegate->Start(std::move(request_info), http_session_.get(),
  889. callback.callback());
  890. // Wait until the stream is ready.
  891. callback.WaitForResult();
  892. // Send a DATA frame.
  893. scoped_refptr<StringIOBuffer> buf =
  894. base::MakeRefCounted<StringIOBuffer>(body_data.substr(0, 5));
  895. scoped_refptr<StringIOBuffer> buf2 = base::MakeRefCounted<StringIOBuffer>(
  896. body_data.substr(5, body_data.size() - 5));
  897. delegate->SendvData({buf, buf2.get()}, {buf->size(), buf2->size()}, true);
  898. sequenced_data_->RunUntilPaused(); // OnHeadersReceived.
  899. // ReadData and it should return asynchronously because no data is buffered.
  900. EXPECT_THAT(delegate->ReadData(), IsError(ERR_IO_PENDING));
  901. sequenced_data_->Resume();
  902. base::RunLoop().RunUntilIdle();
  903. EXPECT_EQ(1, delegate->on_data_sent_count());
  904. EXPECT_EQ(1, delegate->on_data_read_count());
  905. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  906. EXPECT_EQ(1, delegate->on_data_read_count());
  907. EXPECT_EQ(1, delegate->on_data_sent_count());
  908. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  909. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  910. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  911. auto entries = net_log_observer_.GetEntries();
  912. size_t index = ExpectLogContainsSomewhere(
  913. entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_SENDV_DATA,
  914. NetLogEventPhase::NONE);
  915. EXPECT_EQ(2, GetIntegerValueFromParams(entries[index], "num_buffers"));
  916. index = ExpectLogContainsSomewhereAfter(
  917. entries, index,
  918. NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
  919. NetLogEventPhase::BEGIN);
  920. EXPECT_EQ(2,
  921. GetIntegerValueFromParams(entries[index], "num_buffers_coalesced"));
  922. index = ExpectLogContainsSomewhereAfter(
  923. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
  924. NetLogEventPhase::NONE);
  925. EXPECT_EQ(buf->size(),
  926. GetIntegerValueFromParams(entries[index], "byte_count"));
  927. index = ExpectLogContainsSomewhereAfter(
  928. entries, index + 1, NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT,
  929. NetLogEventPhase::NONE);
  930. EXPECT_EQ(buf2->size(),
  931. GetIntegerValueFromParams(entries[index], "byte_count"));
  932. ExpectLogContainsSomewhere(
  933. entries, index,
  934. NetLogEventType::BIDIRECTIONAL_STREAM_BYTES_SENT_COALESCED,
  935. NetLogEventPhase::END);
  936. }
  937. // Tests that BidirectionalStreamSpdyImpl::OnClose will complete any remaining
  938. // read even if the read queue is empty.
  939. TEST_F(BidirectionalStreamTest, TestCompleteAsyncRead) {
  940. spdy::SpdySerializedFrame req(
  941. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  942. MockWrite writes[] = {CreateMockWrite(req, 0)};
  943. spdy::SpdySerializedFrame resp(
  944. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  945. spdy::SpdySerializedFrame response_body_frame(
  946. spdy_util_.ConstructSpdyDataFrame(1, "", true));
  947. MockRead reads[] = {
  948. CreateMockRead(resp, 1),
  949. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  950. CreateMockRead(response_body_frame, 3), MockRead(SYNCHRONOUS, 0, 4),
  951. };
  952. InitSession(reads, writes, SocketTag());
  953. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  954. request_info->method = "GET";
  955. request_info->url = default_url_;
  956. request_info->priority = LOWEST;
  957. request_info->end_stream_on_headers = true;
  958. scoped_refptr<IOBuffer> read_buffer =
  959. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  960. auto timer = std::make_unique<MockTimer>();
  961. MockTimer* timer_ptr = timer.get();
  962. auto delegate = std::make_unique<TestDelegateBase>(
  963. read_buffer.get(), kReadBufferSize, std::move(timer));
  964. delegate->set_do_not_start_read(true);
  965. delegate->Start(std::move(request_info), http_session_.get());
  966. // Write request, and deliver response headers.
  967. sequenced_data_->RunUntilPaused();
  968. EXPECT_FALSE(timer_ptr->IsRunning());
  969. // ReadData should return asynchronously because no data is buffered.
  970. int rv = delegate->ReadData();
  971. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  972. // Deliver END_STREAM.
  973. // OnClose should trigger completion of the remaining read.
  974. sequenced_data_->Resume();
  975. base::RunLoop().RunUntilIdle();
  976. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  977. EXPECT_EQ(1, delegate->on_data_read_count());
  978. EXPECT_EQ(0u, delegate->data_received().size());
  979. EXPECT_EQ(0, delegate->on_data_sent_count());
  980. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  981. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  982. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  983. }
  984. TEST_F(BidirectionalStreamTest, TestBuffering) {
  985. spdy::SpdySerializedFrame req(
  986. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  987. MockWrite writes[] = {CreateMockWrite(req, 0)};
  988. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  989. spdy::SpdySerializedFrame resp(
  990. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  991. spdy::SpdySerializedFrame body_frame(
  992. spdy_util_.ConstructSpdyDataFrame(1, false));
  993. // Last body frame has END_STREAM flag set.
  994. spdy::SpdySerializedFrame last_body_frame(
  995. spdy_util_.ConstructSpdyDataFrame(1, true));
  996. MockRead reads[] = {
  997. CreateMockRead(resp, 1),
  998. CreateMockRead(body_frame, 2),
  999. CreateMockRead(body_frame, 3),
  1000. MockRead(ASYNC, ERR_IO_PENDING, 4), // Force a pause.
  1001. CreateMockRead(last_body_frame, 5),
  1002. MockRead(SYNCHRONOUS, 0, 6),
  1003. };
  1004. InitSession(reads, writes, SocketTag());
  1005. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1006. request_info->method = "GET";
  1007. request_info->url = default_url_;
  1008. request_info->priority = LOWEST;
  1009. request_info->end_stream_on_headers = true;
  1010. scoped_refptr<IOBuffer> read_buffer =
  1011. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1012. auto timer = std::make_unique<MockTimer>();
  1013. MockTimer* timer_ptr = timer.get();
  1014. auto delegate = std::make_unique<TestDelegateBase>(
  1015. read_buffer.get(), kReadBufferSize, std::move(timer));
  1016. delegate->Start(std::move(request_info), http_session_.get());
  1017. // Deliver two DATA frames together.
  1018. sequenced_data_->RunUntilPaused();
  1019. EXPECT_TRUE(timer_ptr->IsRunning());
  1020. timer_ptr->Fire();
  1021. base::RunLoop().RunUntilIdle();
  1022. // This should trigger |more_read_data_pending_| to execute the task at a
  1023. // later time, and Delegate::OnReadComplete should not have been called.
  1024. EXPECT_TRUE(timer_ptr->IsRunning());
  1025. EXPECT_EQ(0, delegate->on_data_read_count());
  1026. // Fire the timer now, the two DATA frame should be combined into one
  1027. // single Delegate::OnReadComplete callback.
  1028. timer_ptr->Fire();
  1029. base::RunLoop().RunUntilIdle();
  1030. EXPECT_EQ(1, delegate->on_data_read_count());
  1031. EXPECT_EQ(kUploadDataSize * 2,
  1032. static_cast<int>(delegate->data_received().size()));
  1033. // Deliver last DATA frame and EOF. There will be an additional
  1034. // Delegate::OnReadComplete callback.
  1035. sequenced_data_->Resume();
  1036. base::RunLoop().RunUntilIdle();
  1037. EXPECT_EQ(2, delegate->on_data_read_count());
  1038. EXPECT_EQ(kUploadDataSize * 3,
  1039. static_cast<int>(delegate->data_received().size()));
  1040. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1041. EXPECT_EQ("200", response_headers.find(":status")->second);
  1042. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  1043. EXPECT_EQ(0, delegate->on_data_sent_count());
  1044. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1045. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  1046. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1047. }
  1048. TEST_F(BidirectionalStreamTest, TestBufferingWithTrailers) {
  1049. spdy::SpdySerializedFrame req(
  1050. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1051. MockWrite writes[] = {
  1052. CreateMockWrite(req, 0),
  1053. };
  1054. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  1055. spdy::SpdySerializedFrame resp(
  1056. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  1057. spdy::SpdySerializedFrame body_frame(
  1058. spdy_util_.ConstructSpdyDataFrame(1, false));
  1059. spdy::Http2HeaderBlock trailers;
  1060. trailers["foo"] = "bar";
  1061. spdy::SpdySerializedFrame response_trailers(
  1062. spdy_util_.ConstructSpdyResponseHeaders(1, std::move(trailers), true));
  1063. MockRead reads[] = {
  1064. CreateMockRead(resp, 1),
  1065. CreateMockRead(body_frame, 2),
  1066. CreateMockRead(body_frame, 3),
  1067. CreateMockRead(body_frame, 4),
  1068. MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause.
  1069. CreateMockRead(response_trailers, 6),
  1070. MockRead(SYNCHRONOUS, 0, 7),
  1071. };
  1072. InitSession(reads, writes, SocketTag());
  1073. scoped_refptr<IOBuffer> read_buffer =
  1074. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1075. auto timer = std::make_unique<MockTimer>();
  1076. MockTimer* timer_ptr = timer.get();
  1077. auto delegate = std::make_unique<TestDelegateBase>(
  1078. read_buffer.get(), kReadBufferSize, std::move(timer));
  1079. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1080. request_info->method = "GET";
  1081. request_info->url = default_url_;
  1082. request_info->priority = LOWEST;
  1083. request_info->end_stream_on_headers = true;
  1084. delegate->Start(std::move(request_info), http_session_.get());
  1085. // Deliver all three DATA frames together.
  1086. sequenced_data_->RunUntilPaused();
  1087. EXPECT_TRUE(timer_ptr->IsRunning());
  1088. timer_ptr->Fire();
  1089. base::RunLoop().RunUntilIdle();
  1090. // This should trigger |more_read_data_pending_| to execute the task at a
  1091. // later time, and Delegate::OnReadComplete should not have been called.
  1092. EXPECT_TRUE(timer_ptr->IsRunning());
  1093. EXPECT_EQ(0, delegate->on_data_read_count());
  1094. // Deliver trailers. Remaining read should be completed, since OnClose is
  1095. // called right after OnTrailersReceived. The three DATA frames should be
  1096. // delivered in a single OnReadCompleted callback.
  1097. sequenced_data_->Resume();
  1098. base::RunLoop().RunUntilIdle();
  1099. EXPECT_EQ(1, delegate->on_data_read_count());
  1100. EXPECT_EQ(kUploadDataSize * 3,
  1101. static_cast<int>(delegate->data_received().size()));
  1102. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1103. EXPECT_EQ("200", response_headers.find(":status")->second);
  1104. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  1105. EXPECT_EQ("bar", delegate->trailers().find("foo")->second);
  1106. EXPECT_EQ(0, delegate->on_data_sent_count());
  1107. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1108. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  1109. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1110. }
  1111. TEST_F(BidirectionalStreamTest, DeleteStreamAfterSendData) {
  1112. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  1113. kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
  1114. spdy::SpdySerializedFrame data_frame(
  1115. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/false));
  1116. spdy::SpdySerializedFrame rst(
  1117. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL));
  1118. MockWrite writes[] = {
  1119. CreateMockWrite(req, 0), CreateMockWrite(data_frame, 3),
  1120. CreateMockWrite(rst, 5),
  1121. };
  1122. spdy::SpdySerializedFrame resp(
  1123. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  1124. MockRead reads[] = {
  1125. CreateMockRead(resp, 1),
  1126. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  1127. MockRead(ASYNC, ERR_IO_PENDING, 4), // Force a pause.
  1128. MockRead(ASYNC, 0, 6),
  1129. };
  1130. InitSession(reads, writes, SocketTag());
  1131. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1132. request_info->method = "POST";
  1133. request_info->url = default_url_;
  1134. request_info->priority = LOWEST;
  1135. request_info->extra_headers.SetHeader(
  1136. net::HttpRequestHeaders::kContentLength,
  1137. base::NumberToString(kBodyDataSize * 3));
  1138. scoped_refptr<IOBuffer> read_buffer =
  1139. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1140. auto delegate =
  1141. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  1142. delegate->set_do_not_start_read(true);
  1143. delegate->Start(std::move(request_info), http_session_.get());
  1144. // Send the request and receive response headers.
  1145. sequenced_data_->RunUntilPaused();
  1146. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1147. // Send a DATA frame.
  1148. scoped_refptr<StringIOBuffer> buf =
  1149. base::MakeRefCounted<StringIOBuffer>(kBodyDataString);
  1150. delegate->SendData(buf, buf->size(), false);
  1151. sequenced_data_->Resume();
  1152. base::RunLoop().RunUntilIdle();
  1153. delegate->DeleteStream();
  1154. sequenced_data_->Resume();
  1155. base::RunLoop().RunUntilIdle();
  1156. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  1157. EXPECT_EQ(0, delegate->on_data_read_count());
  1158. // OnDataSent may or may not have been invoked.
  1159. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1160. // Bytes sent excludes the RST frame.
  1161. EXPECT_EQ(
  1162. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1163. delegate->GetTotalSentBytes());
  1164. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1165. }
  1166. TEST_F(BidirectionalStreamTest, DeleteStreamDuringReadData) {
  1167. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  1168. kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
  1169. spdy::SpdySerializedFrame rst(
  1170. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL));
  1171. MockWrite writes[] = {
  1172. CreateMockWrite(req, 0), CreateMockWrite(rst, 4),
  1173. };
  1174. spdy::SpdySerializedFrame resp(
  1175. spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
  1176. spdy::SpdySerializedFrame response_body_frame(
  1177. spdy_util_.ConstructSpdyDataFrame(1, false));
  1178. MockRead reads[] = {
  1179. CreateMockRead(resp, 1),
  1180. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  1181. CreateMockRead(response_body_frame, 3), MockRead(ASYNC, 0, 5),
  1182. };
  1183. InitSession(reads, writes, SocketTag());
  1184. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1185. request_info->method = "POST";
  1186. request_info->url = default_url_;
  1187. request_info->priority = LOWEST;
  1188. request_info->extra_headers.SetHeader(
  1189. net::HttpRequestHeaders::kContentLength,
  1190. base::NumberToString(kBodyDataSize * 3));
  1191. scoped_refptr<IOBuffer> read_buffer =
  1192. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1193. auto delegate =
  1194. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  1195. delegate->set_do_not_start_read(true);
  1196. delegate->Start(std::move(request_info), http_session_.get());
  1197. // Send the request and receive response headers.
  1198. base::RunLoop().RunUntilIdle();
  1199. EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
  1200. // Delete the stream after ReadData returns ERR_IO_PENDING.
  1201. int rv = delegate->ReadData();
  1202. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1203. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1204. delegate->DeleteStream();
  1205. sequenced_data_->Resume();
  1206. base::RunLoop().RunUntilIdle();
  1207. EXPECT_EQ(0, delegate->on_data_read_count());
  1208. EXPECT_EQ(0, delegate->on_data_sent_count());
  1209. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1210. // Bytes sent excludes the RST frame.
  1211. EXPECT_EQ(
  1212. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1213. delegate->GetTotalSentBytes());
  1214. // Response body frame isn't read becase stream is deleted once read returns
  1215. // ERR_IO_PENDING.
  1216. EXPECT_EQ(CountReadBytes(base::make_span(reads).first(std::size(reads) - 2)),
  1217. delegate->GetTotalReceivedBytes());
  1218. }
  1219. // Receiving a header with uppercase ASCII will result in a protocol error,
  1220. // which should be propagated via Delegate::OnFailed.
  1221. TEST_F(BidirectionalStreamTest, PropagateProtocolError) {
  1222. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  1223. kDefaultUrl, 1, kBodyDataSize * 3, LOW, nullptr, 0));
  1224. spdy::SpdySerializedFrame rst(
  1225. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_PROTOCOL_ERROR));
  1226. MockWrite writes[] = {
  1227. CreateMockWrite(req, 0), CreateMockWrite(rst, 2),
  1228. };
  1229. const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
  1230. spdy::SpdySerializedFrame resp(
  1231. spdy_util_.ConstructSpdyGetReply(kExtraHeaders, 1, 1));
  1232. MockRead reads[] = {
  1233. CreateMockRead(resp, 1), MockRead(ASYNC, 0, 3),
  1234. };
  1235. InitSession(reads, writes, SocketTag());
  1236. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1237. request_info->method = "POST";
  1238. request_info->url = default_url_;
  1239. request_info->extra_headers.SetHeader(
  1240. net::HttpRequestHeaders::kContentLength,
  1241. base::NumberToString(kBodyDataSize * 3));
  1242. scoped_refptr<IOBuffer> read_buffer =
  1243. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1244. auto delegate =
  1245. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  1246. delegate->SetRunUntilCompletion(true);
  1247. delegate->Start(std::move(request_info), http_session_.get());
  1248. base::RunLoop().RunUntilIdle();
  1249. EXPECT_THAT(delegate->error(), IsError(ERR_HTTP2_PROTOCOL_ERROR));
  1250. EXPECT_EQ(delegate->response_headers().end(),
  1251. delegate->response_headers().find(":status"));
  1252. EXPECT_EQ(0, delegate->on_data_read_count());
  1253. EXPECT_EQ(0, delegate->on_data_sent_count());
  1254. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1255. // BidirectionalStreamSpdyStreamJob does not count the bytes sent for |rst|
  1256. // because it is sent after SpdyStream::Delegate::OnClose is called.
  1257. EXPECT_EQ(CountWriteBytes(base::make_span(writes, 1)),
  1258. delegate->GetTotalSentBytes());
  1259. EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
  1260. auto entries = net_log_observer_.GetEntries();
  1261. size_t index = ExpectLogContainsSomewhere(
  1262. entries, 0, NetLogEventType::BIDIRECTIONAL_STREAM_READY,
  1263. NetLogEventPhase::NONE);
  1264. EXPECT_TRUE(
  1265. GetBooleanValueFromParams(entries[index], "request_headers_sent"));
  1266. index = ExpectLogContainsSomewhere(
  1267. entries, index, NetLogEventType::BIDIRECTIONAL_STREAM_FAILED,
  1268. NetLogEventPhase::NONE);
  1269. EXPECT_EQ(ERR_HTTP2_PROTOCOL_ERROR,
  1270. GetNetErrorCodeFromParams(entries[index]));
  1271. }
  1272. TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnHeadersReceived) {
  1273. spdy::SpdySerializedFrame req(
  1274. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1275. spdy::SpdySerializedFrame rst(
  1276. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL));
  1277. MockWrite writes[] = {
  1278. CreateMockWrite(req, 0), CreateMockWrite(rst, 2),
  1279. };
  1280. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  1281. spdy::SpdySerializedFrame resp(
  1282. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  1283. MockRead reads[] = {
  1284. CreateMockRead(resp, 1), MockRead(ASYNC, 0, 3),
  1285. };
  1286. InitSession(reads, writes, SocketTag());
  1287. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1288. request_info->method = "GET";
  1289. request_info->url = default_url_;
  1290. request_info->priority = LOWEST;
  1291. request_info->end_stream_on_headers = true;
  1292. scoped_refptr<IOBuffer> read_buffer =
  1293. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1294. auto delegate = std::make_unique<DeleteStreamDelegate>(
  1295. read_buffer.get(), kReadBufferSize,
  1296. DeleteStreamDelegate::Phase::ON_HEADERS_RECEIVED);
  1297. delegate->SetRunUntilCompletion(true);
  1298. delegate->Start(std::move(request_info), http_session_.get());
  1299. // Makes sure delegate does not get called.
  1300. base::RunLoop().RunUntilIdle();
  1301. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1302. EXPECT_EQ("200", response_headers.find(":status")->second);
  1303. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  1304. EXPECT_EQ(0u, delegate->data_received().size());
  1305. EXPECT_EQ(0, delegate->on_data_sent_count());
  1306. EXPECT_EQ(0, delegate->on_data_read_count());
  1307. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1308. // Bytes sent excludes the RST frame.
  1309. EXPECT_EQ(
  1310. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1311. delegate->GetTotalSentBytes());
  1312. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1313. }
  1314. TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnDataRead) {
  1315. spdy::SpdySerializedFrame req(
  1316. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1317. spdy::SpdySerializedFrame rst(
  1318. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL));
  1319. MockWrite writes[] = {
  1320. CreateMockWrite(req, 0), CreateMockWrite(rst, 3),
  1321. };
  1322. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  1323. spdy::SpdySerializedFrame resp(
  1324. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  1325. spdy::SpdySerializedFrame response_body_frame(
  1326. spdy_util_.ConstructSpdyDataFrame(1, false));
  1327. MockRead reads[] = {
  1328. CreateMockRead(resp, 1), CreateMockRead(response_body_frame, 2),
  1329. MockRead(ASYNC, 0, 4),
  1330. };
  1331. InitSession(reads, writes, SocketTag());
  1332. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1333. request_info->method = "GET";
  1334. request_info->url = default_url_;
  1335. request_info->priority = LOWEST;
  1336. request_info->end_stream_on_headers = true;
  1337. scoped_refptr<IOBuffer> read_buffer =
  1338. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1339. auto delegate = std::make_unique<DeleteStreamDelegate>(
  1340. read_buffer.get(), kReadBufferSize,
  1341. DeleteStreamDelegate::Phase::ON_DATA_READ);
  1342. delegate->SetRunUntilCompletion(true);
  1343. delegate->Start(std::move(request_info), http_session_.get());
  1344. // Makes sure delegate does not get called.
  1345. base::RunLoop().RunUntilIdle();
  1346. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1347. EXPECT_EQ("200", response_headers.find(":status")->second);
  1348. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  1349. EXPECT_EQ(kUploadDataSize * 1,
  1350. static_cast<int>(delegate->data_received().size()));
  1351. EXPECT_EQ(0, delegate->on_data_sent_count());
  1352. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1353. // Bytes sent excludes the RST frame.
  1354. EXPECT_EQ(
  1355. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1356. delegate->GetTotalSentBytes());
  1357. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1358. }
  1359. TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnTrailersReceived) {
  1360. spdy::SpdySerializedFrame req(
  1361. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1362. spdy::SpdySerializedFrame rst(
  1363. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL));
  1364. MockWrite writes[] = {
  1365. CreateMockWrite(req, 0), CreateMockWrite(rst, 4),
  1366. };
  1367. const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
  1368. spdy::SpdySerializedFrame resp(
  1369. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  1370. spdy::SpdySerializedFrame response_body_frame(
  1371. spdy_util_.ConstructSpdyDataFrame(1, false));
  1372. spdy::Http2HeaderBlock trailers;
  1373. trailers["foo"] = "bar";
  1374. spdy::SpdySerializedFrame response_trailers(
  1375. spdy_util_.ConstructSpdyResponseHeaders(1, std::move(trailers), true));
  1376. MockRead reads[] = {
  1377. CreateMockRead(resp, 1), CreateMockRead(response_body_frame, 2),
  1378. CreateMockRead(response_trailers, 3), MockRead(ASYNC, 0, 5),
  1379. };
  1380. InitSession(reads, writes, SocketTag());
  1381. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1382. request_info->method = "GET";
  1383. request_info->url = default_url_;
  1384. request_info->priority = LOWEST;
  1385. request_info->end_stream_on_headers = true;
  1386. scoped_refptr<IOBuffer> read_buffer =
  1387. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1388. auto delegate = std::make_unique<DeleteStreamDelegate>(
  1389. read_buffer.get(), kReadBufferSize,
  1390. DeleteStreamDelegate::Phase::ON_TRAILERS_RECEIVED);
  1391. delegate->SetRunUntilCompletion(true);
  1392. delegate->Start(std::move(request_info), http_session_.get());
  1393. // Makes sure delegate does not get called.
  1394. base::RunLoop().RunUntilIdle();
  1395. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1396. EXPECT_EQ("200", response_headers.find(":status")->second);
  1397. EXPECT_EQ("header-value", response_headers.find("header-name")->second);
  1398. EXPECT_EQ("bar", delegate->trailers().find("foo")->second);
  1399. EXPECT_EQ(0, delegate->on_data_sent_count());
  1400. // OnDataRead may or may not have been fired before the stream is
  1401. // deleted.
  1402. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1403. // Bytes sent excludes the RST frame.
  1404. EXPECT_EQ(
  1405. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1406. delegate->GetTotalSentBytes());
  1407. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1408. }
  1409. TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnFailed) {
  1410. spdy::SpdySerializedFrame req(
  1411. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1412. spdy::SpdySerializedFrame rst(
  1413. spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_PROTOCOL_ERROR));
  1414. MockWrite writes[] = {
  1415. CreateMockWrite(req, 0), CreateMockWrite(rst, 2),
  1416. };
  1417. const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
  1418. spdy::SpdySerializedFrame resp(
  1419. spdy_util_.ConstructSpdyGetReply(kExtraHeaders, 1, 1));
  1420. MockRead reads[] = {
  1421. CreateMockRead(resp, 1), MockRead(ASYNC, 0, 3),
  1422. };
  1423. InitSession(reads, writes, SocketTag());
  1424. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1425. request_info->method = "GET";
  1426. request_info->url = default_url_;
  1427. request_info->priority = LOWEST;
  1428. request_info->end_stream_on_headers = true;
  1429. scoped_refptr<IOBuffer> read_buffer =
  1430. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1431. auto delegate = std::make_unique<DeleteStreamDelegate>(
  1432. read_buffer.get(), kReadBufferSize,
  1433. DeleteStreamDelegate::Phase::ON_FAILED);
  1434. delegate->SetRunUntilCompletion(true);
  1435. delegate->Start(std::move(request_info), http_session_.get());
  1436. // Makes sure delegate does not get called.
  1437. base::RunLoop().RunUntilIdle();
  1438. EXPECT_EQ(delegate->response_headers().end(),
  1439. delegate->response_headers().find(":status"));
  1440. EXPECT_EQ(0, delegate->on_data_sent_count());
  1441. EXPECT_EQ(0, delegate->on_data_read_count());
  1442. EXPECT_THAT(delegate->error(), IsError(ERR_HTTP2_PROTOCOL_ERROR));
  1443. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1444. // Bytes sent excludes the RST frame.
  1445. EXPECT_EQ(
  1446. CountWriteBytes(base::make_span(writes).first(std::size(writes) - 1)),
  1447. delegate->GetTotalSentBytes());
  1448. EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
  1449. }
  1450. TEST_F(BidirectionalStreamTest, TestHonorAlternativeServiceHeader) {
  1451. spdy::SpdySerializedFrame req(
  1452. spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
  1453. MockWrite writes[] = {CreateMockWrite(req, 0)};
  1454. std::string alt_svc_header_value =
  1455. quic::AlpnForVersion(DefaultSupportedQuicVersions().front());
  1456. alt_svc_header_value.append("=\"www.example.org:443\"");
  1457. const char* const kExtraResponseHeaders[] = {"alt-svc",
  1458. alt_svc_header_value.c_str()};
  1459. spdy::SpdySerializedFrame resp(
  1460. spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
  1461. spdy::SpdySerializedFrame body_frame(
  1462. spdy_util_.ConstructSpdyDataFrame(1, true));
  1463. MockRead reads[] = {
  1464. CreateMockRead(resp, 1), CreateMockRead(body_frame, 2),
  1465. MockRead(SYNCHRONOUS, 0, 3),
  1466. };
  1467. // Enable QUIC so that the alternative service header can be added to
  1468. // HttpServerProperties.
  1469. session_deps_.enable_quic = true;
  1470. InitSession(reads, writes, SocketTag());
  1471. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1472. request_info->method = "GET";
  1473. request_info->url = default_url_;
  1474. request_info->priority = LOWEST;
  1475. request_info->end_stream_on_headers = true;
  1476. scoped_refptr<IOBuffer> read_buffer =
  1477. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1478. auto timer = std::make_unique<MockTimer>();
  1479. auto delegate = std::make_unique<TestDelegateBase>(
  1480. read_buffer.get(), kReadBufferSize, std::move(timer));
  1481. delegate->SetRunUntilCompletion(true);
  1482. delegate->Start(std::move(request_info), http_session_.get());
  1483. const spdy::Http2HeaderBlock& response_headers = delegate->response_headers();
  1484. EXPECT_EQ("200", response_headers.find(":status")->second);
  1485. EXPECT_EQ(alt_svc_header_value, response_headers.find("alt-svc")->second);
  1486. EXPECT_EQ(0, delegate->on_data_sent_count());
  1487. EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
  1488. EXPECT_EQ(kUploadData, delegate->data_received());
  1489. EXPECT_EQ(CountWriteBytes(writes), delegate->GetTotalSentBytes());
  1490. EXPECT_EQ(CountReadBytes(reads), delegate->GetTotalReceivedBytes());
  1491. AlternativeServiceInfoVector alternative_service_info_vector =
  1492. http_session_->http_server_properties()->GetAlternativeServiceInfos(
  1493. url::SchemeHostPort(default_url_), NetworkIsolationKey());
  1494. ASSERT_EQ(1u, alternative_service_info_vector.size());
  1495. AlternativeService alternative_service(kProtoQUIC, "www.example.org", 443);
  1496. EXPECT_EQ(alternative_service,
  1497. alternative_service_info_vector[0].alternative_service());
  1498. }
  1499. // Test that a BidirectionalStream created with a specific tag, tags the
  1500. // underlying socket appropriately.
  1501. TEST_F(BidirectionalStreamTest, Tagging) {
  1502. spdy::SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
  1503. kDefaultUrl, 1, kBodyDataSize, LOW, nullptr, 0));
  1504. spdy::SpdySerializedFrame data_frame(
  1505. spdy_util_.ConstructSpdyDataFrame(1, kBodyDataString, /*fin=*/true));
  1506. MockWrite writes[] = {
  1507. CreateMockWrite(req, 0), CreateMockWrite(data_frame, 3),
  1508. };
  1509. spdy::SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostReply(nullptr, 0));
  1510. spdy::SpdySerializedFrame response_body_frame(
  1511. spdy_util_.ConstructSpdyDataFrame(1, /*fin=*/true));
  1512. MockRead reads[] = {
  1513. CreateMockRead(resp, 1),
  1514. MockRead(ASYNC, ERR_IO_PENDING, 2), // Force a pause.
  1515. CreateMockRead(response_body_frame, 4), MockRead(ASYNC, 0, 5),
  1516. };
  1517. #if BUILDFLAG(IS_ANDROID)
  1518. SocketTag tag(0x12345678, 0x87654321);
  1519. #else
  1520. SocketTag tag;
  1521. #endif
  1522. InitSession(reads, writes, tag);
  1523. auto request_info = std::make_unique<BidirectionalStreamRequestInfo>();
  1524. request_info->method = "POST";
  1525. request_info->url = default_url_;
  1526. request_info->extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
  1527. base::NumberToString(kBodyDataSize));
  1528. request_info->socket_tag = tag;
  1529. scoped_refptr<IOBuffer> read_buffer =
  1530. base::MakeRefCounted<IOBuffer>(kReadBufferSize);
  1531. auto delegate =
  1532. std::make_unique<TestDelegateBase>(read_buffer.get(), kReadBufferSize);
  1533. delegate->Start(std::move(request_info), http_session_.get());
  1534. sequenced_data_->RunUntilPaused();
  1535. EXPECT_EQ(socket_factory_->GetLastProducedTCPSocket()->tag(), tag);
  1536. EXPECT_TRUE(
  1537. socket_factory_->GetLastProducedTCPSocket()->tagged_before_connected());
  1538. void* socket = socket_factory_->GetLastProducedTCPSocket();
  1539. scoped_refptr<StringIOBuffer> buf =
  1540. base::MakeRefCounted<StringIOBuffer>(kBodyDataString);
  1541. delegate->SendData(buf.get(), buf->size(), true);
  1542. sequenced_data_->Resume();
  1543. base::RunLoop().RunUntilIdle();
  1544. EXPECT_EQ(socket, socket_factory_->GetLastProducedTCPSocket());
  1545. }
  1546. } // namespace net