OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_stream_sequencer.h" | 5 #include "net/quic/quic_stream_sequencer.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
99 return false; | 99 return false; |
100 } | 100 } |
101 if (memcmp(iovec.iov_base, expected.data(), expected.length()) != 0) { | 101 if (memcmp(iovec.iov_base, expected.data(), expected.length()) != 0) { |
102 LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base) | 102 LOG(ERROR) << "Invalid data: " << static_cast<char*>(iovec.iov_base) |
103 << " vs " << expected.data(); | 103 << " vs " << expected.data(); |
104 return false; | 104 return false; |
105 } | 105 } |
106 return true; | 106 return true; |
107 } | 107 } |
108 | 108 |
109 bool OnFinFrame(QuicStreamOffset byte_offset, const char* data) { | 109 void OnFinFrame(QuicStreamOffset byte_offset, const char* data) { |
110 QuicStreamFrame frame; | 110 QuicStreamFrame frame; |
111 frame.stream_id = 1; | 111 frame.stream_id = 1; |
112 frame.offset = byte_offset; | 112 frame.offset = byte_offset; |
113 frame.data.Append(const_cast<char*>(data), strlen(data)); | 113 frame.data.Append(const_cast<char*>(data), strlen(data)); |
114 frame.fin = true; | 114 frame.fin = true; |
115 return sequencer_->OnStreamFrame(frame); | 115 sequencer_->OnStreamFrame(frame); |
116 } | 116 } |
117 | 117 |
118 bool OnFrame(QuicStreamOffset byte_offset, const char* data) { | 118 void OnFrame(QuicStreamOffset byte_offset, const char* data) { |
119 QuicStreamFrame frame; | 119 QuicStreamFrame frame; |
120 frame.stream_id = 1; | 120 frame.stream_id = 1; |
121 frame.offset = byte_offset; | 121 frame.offset = byte_offset; |
122 frame.data.Append(const_cast<char*>(data), strlen(data)); | 122 frame.data.Append(const_cast<char*>(data), strlen(data)); |
123 frame.fin = false; | 123 frame.fin = false; |
124 return sequencer_->OnStreamFrame(frame); | 124 sequencer_->OnStreamFrame(frame); |
125 } | 125 } |
126 | 126 |
127 MockConnection* connection_; | 127 MockConnection* connection_; |
128 MockSession session_; | 128 MockSession session_; |
129 testing::StrictMock<MockStream> stream_; | 129 testing::StrictMock<MockStream> stream_; |
130 scoped_ptr<QuicStreamSequencer> sequencer_; | 130 scoped_ptr<QuicStreamSequencer> sequencer_; |
131 map<QuicStreamOffset, string>* buffered_frames_; | 131 map<QuicStreamOffset, string>* buffered_frames_; |
132 }; | 132 }; |
133 | 133 |
134 TEST_F(QuicStreamSequencerTest, RejectOldFrame) { | 134 TEST_F(QuicStreamSequencerTest, RejectOldFrame) { |
135 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 135 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
136 | 136 |
137 EXPECT_TRUE(OnFrame(0, "abc")); | 137 OnFrame(0, "abc"); |
138 EXPECT_EQ(0u, buffered_frames_->size()); | 138 EXPECT_EQ(0u, buffered_frames_->size()); |
139 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); | 139 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); |
140 // Ignore this - it matches a past sequence number and we should not see it | 140 // Ignore this - it matches a past sequence number and we should not see it |
141 // again. | 141 // again. |
142 EXPECT_TRUE(OnFrame(0, "def")); | 142 OnFrame(0, "def"); |
143 EXPECT_EQ(0u, buffered_frames_->size()); | 143 EXPECT_EQ(0u, buffered_frames_->size()); |
144 } | 144 } |
145 | 145 |
146 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) { | 146 TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) { |
147 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)); | 147 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)); |
148 | 148 |
149 EXPECT_TRUE(OnFrame(0, "abc")); | 149 OnFrame(0, "abc"); |
150 EXPECT_EQ(1u, buffered_frames_->size()); | 150 EXPECT_EQ(1u, buffered_frames_->size()); |
151 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 151 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
152 // Ignore this - it matches a buffered frame. | 152 // Ignore this - it matches a buffered frame. |
153 // Right now there's no checking that the payload is consistent. | 153 // Right now there's no checking that the payload is consistent. |
154 EXPECT_TRUE(OnFrame(0, "def")); | 154 OnFrame(0, "def"); |
155 EXPECT_EQ(1u, buffered_frames_->size()); | 155 EXPECT_EQ(1u, buffered_frames_->size()); |
156 } | 156 } |
157 | 157 |
158 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) { | 158 TEST_F(QuicStreamSequencerTest, FullFrameConsumed) { |
159 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 159 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
160 | 160 |
161 EXPECT_TRUE(OnFrame(0, "abc")); | 161 OnFrame(0, "abc"); |
162 EXPECT_EQ(0u, buffered_frames_->size()); | 162 EXPECT_EQ(0u, buffered_frames_->size()); |
163 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); | 163 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); |
164 } | 164 } |
165 | 165 |
166 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) { | 166 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) { |
167 sequencer_->SetBlockedUntilFlush(); | 167 sequencer_->SetBlockedUntilFlush(); |
168 | 168 |
169 EXPECT_TRUE(OnFrame(0, "abc")); | 169 OnFrame(0, "abc"); |
170 EXPECT_EQ(1u, buffered_frames_->size()); | 170 EXPECT_EQ(1u, buffered_frames_->size()); |
171 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 171 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
172 | 172 |
173 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 173 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
174 sequencer_->FlushBufferedFrames(); | 174 sequencer_->FlushBufferedFrames(); |
175 EXPECT_EQ(0u, buffered_frames_->size()); | 175 EXPECT_EQ(0u, buffered_frames_->size()); |
176 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); | 176 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); |
177 | 177 |
178 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); | 178 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); |
179 EXPECT_CALL(stream_, OnFinRead()); | 179 EXPECT_CALL(stream_, OnFinRead()); |
180 EXPECT_TRUE(OnFinFrame(3, "def")); | 180 OnFinFrame(3, "def"); |
181 } | 181 } |
182 | 182 |
183 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) { | 183 TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) { |
184 sequencer_->SetBlockedUntilFlush(); | 184 sequencer_->SetBlockedUntilFlush(); |
185 | 185 |
186 EXPECT_TRUE(OnFinFrame(0, "abc")); | 186 OnFinFrame(0, "abc"); |
187 EXPECT_EQ(1u, buffered_frames_->size()); | 187 EXPECT_EQ(1u, buffered_frames_->size()); |
188 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 188 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
189 | 189 |
190 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 190 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
191 EXPECT_CALL(stream_, OnFinRead()); | 191 EXPECT_CALL(stream_, OnFinRead()); |
192 sequencer_->FlushBufferedFrames(); | 192 sequencer_->FlushBufferedFrames(); |
193 EXPECT_EQ(0u, buffered_frames_->size()); | 193 EXPECT_EQ(0u, buffered_frames_->size()); |
194 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); | 194 EXPECT_EQ(3u, sequencer_->num_bytes_consumed()); |
195 } | 195 } |
196 | 196 |
197 TEST_F(QuicStreamSequencerTest, EmptyFrame) { | 197 TEST_F(QuicStreamSequencerTest, EmptyFrame) { |
198 EXPECT_CALL(stream_, | 198 EXPECT_CALL(stream_, |
199 CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _)); | 199 CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _)); |
200 EXPECT_FALSE(OnFrame(0, "")); | 200 OnFrame(0, ""); |
201 EXPECT_EQ(0u, buffered_frames_->size()); | 201 EXPECT_EQ(0u, buffered_frames_->size()); |
202 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 202 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
203 } | 203 } |
204 | 204 |
205 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) { | 205 TEST_F(QuicStreamSequencerTest, EmptyFinFrame) { |
206 EXPECT_CALL(stream_, OnFinRead()); | 206 EXPECT_CALL(stream_, OnFinRead()); |
207 EXPECT_TRUE(OnFinFrame(0, "")); | 207 OnFinFrame(0, ""); |
208 EXPECT_EQ(0u, buffered_frames_->size()); | 208 EXPECT_EQ(0u, buffered_frames_->size()); |
209 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 209 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
210 } | 210 } |
211 | 211 |
212 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) { | 212 TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) { |
213 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(2)); | 213 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(2)); |
214 | 214 |
215 EXPECT_TRUE(OnFrame(0, "abc")); | 215 OnFrame(0, "abc"); |
216 EXPECT_EQ(1u, buffered_frames_->size()); | 216 EXPECT_EQ(1u, buffered_frames_->size()); |
217 EXPECT_EQ(2u, sequencer_->num_bytes_consumed()); | 217 EXPECT_EQ(2u, sequencer_->num_bytes_consumed()); |
218 EXPECT_EQ("c", buffered_frames_->find(2)->second); | 218 EXPECT_EQ("c", buffered_frames_->find(2)->second); |
219 } | 219 } |
220 | 220 |
221 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) { | 221 TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) { |
222 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0)); | 222 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0)); |
223 | 223 |
224 EXPECT_TRUE(OnFrame(0, "abc")); | 224 OnFrame(0, "abc"); |
225 EXPECT_EQ(1u, buffered_frames_->size()); | 225 EXPECT_EQ(1u, buffered_frames_->size()); |
226 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 226 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
227 EXPECT_EQ("abc", buffered_frames_->find(0)->second); | 227 EXPECT_EQ("abc", buffered_frames_->find(0)->second); |
228 } | 228 } |
229 | 229 |
230 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) { | 230 TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) { |
231 EXPECT_TRUE(OnFrame(3, "abc")); | 231 OnFrame(3, "abc"); |
232 EXPECT_EQ(1u, buffered_frames_->size()); | 232 EXPECT_EQ(1u, buffered_frames_->size()); |
233 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 233 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
234 EXPECT_EQ("abc", buffered_frames_->find(3)->second); | 234 EXPECT_EQ("abc", buffered_frames_->find(3)->second); |
235 } | 235 } |
236 | 236 |
237 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) { | 237 TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) { |
238 // Buffer the first | 238 // Buffer the first |
239 EXPECT_TRUE(OnFrame(6, "ghi")); | 239 OnFrame(6, "ghi"); |
240 EXPECT_EQ(1u, buffered_frames_->size()); | 240 EXPECT_EQ(1u, buffered_frames_->size()); |
241 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 241 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
242 EXPECT_EQ(3u, sequencer_->num_bytes_buffered()); | 242 EXPECT_EQ(3u, sequencer_->num_bytes_buffered()); |
243 // Buffer the second | 243 // Buffer the second |
244 EXPECT_TRUE(OnFrame(3, "def")); | 244 OnFrame(3, "def"); |
245 EXPECT_EQ(2u, buffered_frames_->size()); | 245 EXPECT_EQ(2u, buffered_frames_->size()); |
246 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); | 246 EXPECT_EQ(0u, sequencer_->num_bytes_consumed()); |
247 EXPECT_EQ(6u, sequencer_->num_bytes_buffered()); | 247 EXPECT_EQ(6u, sequencer_->num_bytes_buffered()); |
248 | 248 |
249 InSequence s; | 249 InSequence s; |
250 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 250 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
251 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); | 251 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); |
252 EXPECT_CALL(stream_, ProcessRawData(StrEq("ghi"), 3)).WillOnce(Return(3)); | 252 EXPECT_CALL(stream_, ProcessRawData(StrEq("ghi"), 3)).WillOnce(Return(3)); |
253 | 253 |
254 // Ack right away | 254 // Ack right away |
255 EXPECT_TRUE(OnFrame(0, "abc")); | 255 OnFrame(0, "abc"); |
256 EXPECT_EQ(9u, sequencer_->num_bytes_consumed()); | 256 EXPECT_EQ(9u, sequencer_->num_bytes_consumed()); |
257 EXPECT_EQ(0u, sequencer_->num_bytes_buffered()); | 257 EXPECT_EQ(0u, sequencer_->num_bytes_buffered()); |
258 | 258 |
259 EXPECT_EQ(0u, buffered_frames_->size()); | 259 EXPECT_EQ(0u, buffered_frames_->size()); |
260 } | 260 } |
261 | 261 |
262 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) { | 262 TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) { |
263 InSequence s; | 263 InSequence s; |
264 | 264 |
265 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 265 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
266 EXPECT_CALL(stream_, OnFinRead()); | 266 EXPECT_CALL(stream_, OnFinRead()); |
267 EXPECT_TRUE(OnFinFrame(0, "abc")); | 267 OnFinFrame(0, "abc"); |
268 | 268 |
269 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); | 269 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); |
270 } | 270 } |
271 | 271 |
272 TEST_F(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) { | 272 TEST_F(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) { |
273 OnFinFrame(6, ""); | 273 OnFinFrame(6, ""); |
274 EXPECT_EQ(6u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); | 274 EXPECT_EQ(6u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); |
275 InSequence s; | 275 InSequence s; |
276 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 276 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
277 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); | 277 EXPECT_CALL(stream_, ProcessRawData(StrEq("def"), 3)).WillOnce(Return(3)); |
278 EXPECT_CALL(stream_, OnFinRead()); | 278 EXPECT_CALL(stream_, OnFinRead()); |
279 | 279 |
280 EXPECT_TRUE(OnFrame(3, "def")); | 280 OnFrame(3, "def"); |
281 EXPECT_TRUE(OnFrame(0, "abc")); | 281 OnFrame(0, "abc"); |
282 } | 282 } |
283 | 283 |
284 TEST_F(QuicStreamSequencerTest, BasicHalfUnordered) { | 284 TEST_F(QuicStreamSequencerTest, BasicHalfUnordered) { |
285 OnFinFrame(3, ""); | 285 OnFinFrame(3, ""); |
286 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); | 286 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); |
287 InSequence s; | 287 InSequence s; |
288 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); | 288 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(3)); |
289 EXPECT_CALL(stream_, OnFinRead()); | 289 EXPECT_CALL(stream_, OnFinRead()); |
290 | 290 |
291 EXPECT_TRUE(OnFrame(0, "abc")); | 291 OnFrame(0, "abc"); |
292 } | 292 } |
293 | 293 |
294 TEST_F(QuicStreamSequencerTest, TerminateWithReadv) { | 294 TEST_F(QuicStreamSequencerTest, TerminateWithReadv) { |
295 char buffer[3]; | 295 char buffer[3]; |
296 | 296 |
297 OnFinFrame(3, ""); | 297 OnFinFrame(3, ""); |
298 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); | 298 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); |
299 | 299 |
300 EXPECT_FALSE(sequencer_->IsClosed()); | 300 EXPECT_FALSE(sequencer_->IsClosed()); |
301 | 301 |
302 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0)); | 302 EXPECT_CALL(stream_, ProcessRawData(StrEq("abc"), 3)).WillOnce(Return(0)); |
303 EXPECT_TRUE(OnFrame(0, "abc")); | 303 OnFrame(0, "abc"); |
304 | 304 |
305 iovec iov = {&buffer[0], 3}; | 305 iovec iov = {&buffer[0], 3}; |
306 int bytes_read = sequencer_->Readv(&iov, 1); | 306 int bytes_read = sequencer_->Readv(&iov, 1); |
307 EXPECT_EQ(3, bytes_read); | 307 EXPECT_EQ(3, bytes_read); |
308 EXPECT_TRUE(sequencer_->IsClosed()); | 308 EXPECT_TRUE(sequencer_->IsClosed()); |
309 } | 309 } |
310 | 310 |
311 TEST_F(QuicStreamSequencerTest, MutipleOffsets) { | 311 TEST_F(QuicStreamSequencerTest, MutipleOffsets) { |
312 OnFinFrame(3, ""); | 312 OnFinFrame(3, ""); |
313 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); | 313 EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
367 InSequence s; | 367 InSequence s; |
368 for (size_t i = 0; i < list_.size(); ++i) { | 368 for (size_t i = 0; i < list_.size(); ++i) { |
369 string* data = &list_[i].second; | 369 string* data = &list_[i].second; |
370 EXPECT_CALL(stream_, ProcessRawData(StrEq(*data), data->size())) | 370 EXPECT_CALL(stream_, ProcessRawData(StrEq(*data), data->size())) |
371 .WillOnce(Return(data->size())); | 371 .WillOnce(Return(data->size())); |
372 } | 372 } |
373 | 373 |
374 while (!list_.empty()) { | 374 while (!list_.empty()) { |
375 int index = OneToN(list_.size()) - 1; | 375 int index = OneToN(list_.size()) - 1; |
376 LOG(ERROR) << "Sending index " << index << " " << list_[index].second; | 376 LOG(ERROR) << "Sending index " << index << " " << list_[index].second; |
377 EXPECT_TRUE(OnFrame(list_[index].first, list_[index].second.data())); | 377 OnFrame(list_[index].first, list_[index].second.data()); |
378 | 378 |
379 list_.erase(list_.begin() + index); | 379 list_.erase(list_.begin() + index); |
380 } | 380 } |
381 } | 381 } |
382 | 382 |
383 TEST_F(QuicStreamSequencerTest, FrameOverlapsBufferedData) { | 383 TEST_F(QuicStreamSequencerTest, FrameOverlapsBufferedData) { |
384 // Ensure that FrameOverlapsBufferedData returns appropriate responses when | 384 // Ensure that FrameOverlapsBufferedData returns appropriate responses when |
385 // there is existing data buffered. | 385 // there is existing data buffered. |
386 | 386 |
387 map<QuicStreamOffset, string>* buffered_frames = | 387 map<QuicStreamOffset, string>* buffered_frames = |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
436 QuicStreamFrame frame2(kClientDataStreamId1, false, 2, MakeIOVector("hello")); | 436 QuicStreamFrame frame2(kClientDataStreamId1, false, 2, MakeIOVector("hello")); |
437 EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(frame2)); | 437 EXPECT_TRUE(sequencer_->FrameOverlapsBufferedData(frame2)); |
438 EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _)) | 438 EXPECT_CALL(stream_, CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _)) |
439 .Times(1); | 439 .Times(1); |
440 sequencer_->OnStreamFrame(frame2); | 440 sequencer_->OnStreamFrame(frame2); |
441 } | 441 } |
442 | 442 |
443 } // namespace | 443 } // namespace |
444 } // namespace test | 444 } // namespace test |
445 } // namespace net | 445 } // namespace net |
OLD | NEW |