?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GoogleURLTrackerInfoBarDelegate: Initialize uninitialized member in constructor.
[chromium-blink-merge.git] / net / spdy / spdy_framer_test.cc
blobcd3e5e3702d6c73c1045e143ee1236cb6d4f4b01
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
3 // found in the LICENSE file.
4
5 #include <algorithm>
6 #include <iostream>
7 #include <limits>
8
9 #include "base/compiler_specific.h"
10 #include "base/memory/scoped_ptr.h"
11 #include "net/spdy/hpack_output_stream.h"
12 #include "net/spdy/mock_spdy_framer_visitor.h"
13 #include "net/spdy/spdy_frame_builder.h"
14 #include "net/spdy/spdy_frame_reader.h"
15 #include "net/spdy/spdy_framer.h"
16 #include "net/spdy/spdy_protocol.h"
17 #include "net/spdy/spdy_test_utils.h"
18 #include "testing/gmock/include/gmock/gmock.h"
19 #include "testing/platform_test.h"
20
21 using base::StringPiece;
22 using std::string;
23 using std::max;
24 using std::min;
25 using std::numeric_limits;
26 using testing::ElementsAre;
27 using testing::Pair;
28 using testing::_;
29
30 namespace net {
31
32 namespace test {
33
34 static const size_t kMaxDecompressedSize = 1024;
35
36 class MockDebugVisitor : public SpdyFramerDebugVisitorInterface {
37 public:
38 MOCK_METHOD4(OnSendCompressedFrame, void(SpdyStreamId stream_id,
39 SpdyFrameType type,
40 size_t payload_len,
41 size_t frame_len));
42
43 MOCK_METHOD3(OnReceiveCompressedFrame, void(SpdyStreamId stream_id,
44 SpdyFrameType type,
45 size_t frame_len));
46 };
47
48 class SpdyFramerTestUtil {
49 public:
50 // Decompress a single frame using the decompression context held by
51 // the SpdyFramer. The implemention is meant for use only in tests
52 // and will CHECK fail if the input is anything other than a single,
53 // well-formed compressed frame.
54 //
55 // Returns a new decompressed SpdyFrame.
56 template<class SpdyFrameType> static SpdyFrame* DecompressFrame(
57 SpdyFramer* framer, const SpdyFrameType& frame) {
58 DecompressionVisitor visitor(framer->protocol_version());
59 framer->set_visitor(&visitor);
60 CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
61 CHECK_EQ(SpdyFramer::SPDY_RESET, framer->state());
62 framer->set_visitor(NULL);
63
64 char* buffer = visitor.ReleaseBuffer();
65 CHECK(buffer != NULL);
66 SpdyFrame* decompressed_frame = new SpdyFrame(buffer, visitor.size(), true);
67 SetFrameLength(decompressed_frame,
68 visitor.size() - framer->GetControlFrameHeaderSize(),
69 framer->protocol_version());
70 return decompressed_frame;
71 }
72
73 class DecompressionVisitor : public SpdyFramerVisitorInterface {
74 public:
75 explicit DecompressionVisitor(SpdyMajorVersion version)
76 : version_(version), size_(0), finished_(false) {}
77
78 void ResetBuffer() {
79 CHECK(buffer_.get() == NULL);
80 CHECK_EQ(0u, size_);
81 CHECK(!finished_);
82 buffer_.reset(new char[kMaxDecompressedSize]);
83 }
84
85 virtual void OnError(SpdyFramer* framer) OVERRIDE { LOG(FATAL); }
86 virtual void OnDataFrameHeader(SpdyStreamId stream_id,
87 size_t length,
88 bool fin) OVERRIDE {
89 LOG(FATAL) << "Unexpected data frame header";
90 }
91 virtual void OnStreamFrameData(SpdyStreamId stream_id,
92 const char* data,
93 size_t len,
94 bool fin) OVERRIDE {
95 LOG(FATAL);
96 }
97
98 virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
99 const char* header_data,
100 size_t len) OVERRIDE {
101 CHECK(buffer_.get() != NULL);
102 CHECK_GE(kMaxDecompressedSize, size_ + len);
103 CHECK(!finished_);
104 if (len != 0) {
105 memcpy(buffer_.get() + size_, header_data, len);
106 size_ += len;
107 } else {
108 // Done.
109 finished_ = true;
110 }
111 return true;
112 }
113
114 virtual void OnSynStream(SpdyStreamId stream_id,
115 SpdyStreamId associated_stream_id,
116 SpdyPriority priority,
117 bool fin,
118 bool unidirectional) OVERRIDE {
119 SpdyFramer framer(version_);
120 framer.set_enable_compression(false);
121 SpdySynStreamIR syn_stream(stream_id);
122 syn_stream.set_associated_to_stream_id(associated_stream_id);
123 syn_stream.set_priority(priority);
124 syn_stream.set_fin(fin);
125 syn_stream.set_unidirectional(unidirectional);
126 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
127 ResetBuffer();
128 memcpy(buffer_.get(), frame->data(), framer.GetSynStreamMinimumSize());
129 size_ += framer.GetSynStreamMinimumSize();
130 }
131
132 virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
133 SpdyFramer framer(version_);
134 framer.set_enable_compression(false);
135 SpdyHeadersIR headers(stream_id);
136 headers.set_fin(fin);
137 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
138 ResetBuffer();
139 memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
140 size_ += framer.GetSynStreamMinimumSize();
141 }
142
143 virtual void OnRstStream(SpdyStreamId stream_id,
144 SpdyRstStreamStatus status) OVERRIDE {
145 LOG(FATAL);
146 }
147 virtual void OnSetting(SpdySettingsIds id,
148 uint8 flags,
149 uint32 value) OVERRIDE {
150 LOG(FATAL);
151 }
152 virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
153 LOG(FATAL);
154 }
155 virtual void OnSettingsEnd() OVERRIDE { LOG(FATAL); }
156 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
157 SpdyGoAwayStatus status) OVERRIDE {
158 LOG(FATAL);
159 }
160
161 virtual void OnHeaders(SpdyStreamId stream_id,
162 bool fin,
163 bool end) OVERRIDE {
164 SpdyFramer framer(version_);
165 framer.set_enable_compression(false);
166 SpdyHeadersIR headers(stream_id);
167 headers.set_fin(fin);
168 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
169 ResetBuffer();
170 memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
171 size_ += framer.GetHeadersMinimumSize();
172 }
173
174 virtual void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {
175 LOG(FATAL);
176 }
177
178 virtual void OnPushPromise(SpdyStreamId stream_id,
179 SpdyStreamId promised_stream_id,
180 bool end) OVERRIDE {
181 SpdyFramer framer(version_);
182 framer.set_enable_compression(false);
183 SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
184 scoped_ptr<SpdyFrame> frame(framer.SerializePushPromise(push_promise));
185 ResetBuffer();
186 memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
187 size_ += framer.GetPushPromiseMinimumSize();
188 }
189
190 virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
191 LOG(FATAL);
192 }
193
194 char* ReleaseBuffer() {
195 CHECK(finished_);
196 return buffer_.release();
197 }
198
199 virtual void OnWindowUpdate(SpdyStreamId stream_id,
200 uint32 delta_window_size) OVERRIDE {
201 LOG(FATAL);
202 }
203
204 size_t size() const {
205 CHECK(finished_);
206 return size_;
207 }
208
209 private:
210 SpdyMajorVersion version_;
211 scoped_ptr<char[]> buffer_;
212 size_t size_;
213 bool finished_;
214
215 DISALLOW_COPY_AND_ASSIGN(DecompressionVisitor);
216 };
217
218 private:
219 DISALLOW_COPY_AND_ASSIGN(SpdyFramerTestUtil);
220 };
221
222 class TestSpdyVisitor : public SpdyFramerVisitorInterface,
223 public SpdyFramerDebugVisitorInterface {
224 public:
225 // This is larger than our max frame size because header blocks that
226 // are too long can spill over into CONTINUATION frames.
227 static const size_t kDefaultHeaderBufferSize = 16 * 1024 * 1024;
228
229 explicit TestSpdyVisitor(SpdyMajorVersion version)
230 : framer_(version),
231 use_compression_(false),
232 error_count_(0),
233 syn_frame_count_(0),
234 syn_reply_frame_count_(0),
235 headers_frame_count_(0),
236 push_promise_frame_count_(0),
237 goaway_count_(0),
238 setting_count_(0),
239 settings_ack_sent_(0),
240 settings_ack_received_(0),
241 continuation_count_(0),
242 altsvc_count_(0),
243 test_altsvc_ir_(0),
244 last_window_update_stream_(0),
245 last_window_update_delta_(0),
246 last_push_promise_stream_(0),
247 last_push_promise_promised_stream_(0),
248 data_bytes_(0),
249 fin_frame_count_(0),
250 fin_opaque_data_(),
251 fin_flag_count_(0),
252 zero_length_data_frame_count_(0),
253 control_frame_header_data_count_(0),
254 zero_length_control_frame_header_data_count_(0),
255 data_frame_count_(0),
256 last_payload_len_(0),
257 last_frame_len_(0),
258 header_buffer_(new char[kDefaultHeaderBufferSize]),
259 header_buffer_length_(0),
260 header_buffer_size_(kDefaultHeaderBufferSize),
261 header_stream_id_(-1),
262 header_control_type_(DATA),
263 header_buffer_valid_(false) {
264 }
265
266 virtual void OnError(SpdyFramer* f) OVERRIDE {
267 LOG(INFO) << "SpdyFramer Error: "
268 << SpdyFramer::ErrorCodeToString(f->error_code());
269 ++error_count_;
270 }
271
272 virtual void OnDataFrameHeader(SpdyStreamId stream_id,
273 size_t length,
274 bool fin) OVERRIDE {
275 ++data_frame_count_;
276 header_stream_id_ = stream_id;
277 }
278
279 virtual void OnStreamFrameData(SpdyStreamId stream_id,
280 const char* data,
281 size_t len,
282 bool fin) OVERRIDE {
283 EXPECT_EQ(header_stream_id_, stream_id);
284 if (len == 0)
285 ++zero_length_data_frame_count_;
286
287 data_bytes_ += len;
288 std::cerr << "OnStreamFrameData(" << stream_id << ", \"";
289 if (len > 0) {
290 for (size_t i = 0 ; i < len; ++i) {
291 std::cerr << std::hex << (0xFF & (unsigned int)data[i]) << std::dec;
292 }
293 }
294 std::cerr << "\", " << len << ")\n";
295 }
296
297 virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
298 const char* header_data,
299 size_t len) OVERRIDE {
300 ++control_frame_header_data_count_;
301 CHECK_EQ(header_stream_id_, stream_id);
302 if (len == 0) {
303 ++zero_length_control_frame_header_data_count_;
304 // Indicates end-of-header-block.
305 headers_.clear();
306 CHECK(header_buffer_valid_);
307 size_t parsed_length = framer_.ParseHeaderBlockInBuffer(
308 header_buffer_.get(), header_buffer_length_, &headers_);
309 LOG_IF(DFATAL, header_buffer_length_ != parsed_length)
310 << "Check failed: header_buffer_length_ == parsed_length "
311 << "(" << header_buffer_length_ << " vs. " << parsed_length << ")";
312 return true;
313 }
314 const size_t available = header_buffer_size_ - header_buffer_length_;
315 if (len > available) {
316 header_buffer_valid_ = false;
317 return false;
318 }
319 memcpy(header_buffer_.get() + header_buffer_length_, header_data, len);
320 header_buffer_length_ += len;
321 return true;
322 }
323
324 virtual void OnSynStream(SpdyStreamId stream_id,
325 SpdyStreamId associated_stream_id,
326 SpdyPriority priority,
327 bool fin,
328 bool unidirectional) OVERRIDE {
329 ++syn_frame_count_;
330 InitHeaderStreaming(SYN_STREAM, stream_id);
331 if (fin) {
332 ++fin_flag_count_;
333 }
334 }
335
336 virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
337 ++syn_reply_frame_count_;
338 InitHeaderStreaming(SYN_REPLY, stream_id);
339 if (fin) {
340 ++fin_flag_count_;
341 }
342 }
343
344 virtual void OnRstStream(SpdyStreamId stream_id,
345 SpdyRstStreamStatus status) OVERRIDE {
346 ++fin_frame_count_;
347 }
348
349 virtual bool OnRstStreamFrameData(const char* rst_stream_data,
350 size_t len) OVERRIDE {
351 if ((rst_stream_data != NULL) && (len > 0)) {
352 fin_opaque_data_ += std::string(rst_stream_data, len);
353 }
354 return true;
355 }
356
357 virtual void OnSetting(SpdySettingsIds id,
358 uint8 flags,
359 uint32 value) OVERRIDE {
360 ++setting_count_;
361 }
362
363 virtual void OnSettingsAck() OVERRIDE {
364 DCHECK_LT(SPDY3, framer_.protocol_version());
365 ++settings_ack_received_;
366 }
367
368 virtual void OnSettingsEnd() OVERRIDE {
369 if (framer_.protocol_version() <= SPDY3) { return; }
370 ++settings_ack_sent_;
371 }
372
373 virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
374 DLOG(FATAL);
375 }
376
377 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
378 SpdyGoAwayStatus status) OVERRIDE {
379 ++goaway_count_;
380 }
381
382 virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
383 ++headers_frame_count_;
384 InitHeaderStreaming(HEADERS, stream_id);
385 if (fin) {
386 ++fin_flag_count_;
387 }
388 }
389
390 virtual void OnWindowUpdate(SpdyStreamId stream_id,
391 uint32 delta_window_size) OVERRIDE {
392 last_window_update_stream_ = stream_id;
393 last_window_update_delta_ = delta_window_size;
394 }
395
396 virtual void OnPushPromise(SpdyStreamId stream_id,
397 SpdyStreamId promised_stream_id,
398 bool end) OVERRIDE {
399 ++push_promise_frame_count_;
400 InitHeaderStreaming(PUSH_PROMISE, stream_id);
401 last_push_promise_stream_ = stream_id;
402 last_push_promise_promised_stream_ = promised_stream_id;
403 }
404
405 virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
406 ++continuation_count_;
407 }
408
409 virtual void OnAltSvc(SpdyStreamId stream_id,
410 uint32 max_age,
411 uint16 port,
412 StringPiece protocol_id,
413 StringPiece host,
414 StringPiece origin) OVERRIDE {
415 test_altsvc_ir_.set_stream_id(stream_id);
416 test_altsvc_ir_.set_max_age(max_age);
417 test_altsvc_ir_.set_port(port);
418 test_altsvc_ir_.set_protocol_id(protocol_id.as_string());
419 test_altsvc_ir_.set_host(host.as_string());
420 if (origin.length() > 0) {
421 test_altsvc_ir_.set_origin(origin.as_string());
422 }
423 ++altsvc_count_;
424 }
425
426 virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
427 SpdyFrameType type,
428 size_t payload_len,
429 size_t frame_len) OVERRIDE {
430 last_payload_len_ = payload_len;
431 last_frame_len_ = frame_len;
432 }
433
434 virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
435 SpdyFrameType type,
436 size_t frame_len) OVERRIDE {
437 last_frame_len_ = frame_len;
438 }
439
440 // Convenience function which runs a framer simulation with particular input.
441 void SimulateInFramer(const unsigned char* input, size_t size) {
442 framer_.set_enable_compression(use_compression_);
443 framer_.set_visitor(this);
444 size_t input_remaining = size;
445 const char* input_ptr = reinterpret_cast<const char*>(input);
446 while (input_remaining > 0 &&
447 framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
448 // To make the tests more interesting, we feed random (amd small) chunks
449 // into the framer. This simulates getting strange-sized reads from
450 // the socket.
451 const size_t kMaxReadSize = 32;
452 size_t bytes_read =
453 (rand() % min(input_remaining, kMaxReadSize)) + 1;
454 size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
455 input_remaining -= bytes_processed;
456 input_ptr += bytes_processed;
457 }
458 }
459
460 void InitHeaderStreaming(SpdyFrameType header_control_type,
461 SpdyStreamId stream_id) {
462 DCHECK_GE(header_control_type, FIRST_CONTROL_TYPE);
463 DCHECK_LE(header_control_type, LAST_CONTROL_TYPE);
464 memset(header_buffer_.get(), 0, header_buffer_size_);
465 header_buffer_length_ = 0;
466 header_stream_id_ = stream_id;
467 header_control_type_ = header_control_type;
468 header_buffer_valid_ = true;
469 DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
470 }
471
472 // Override the default buffer size (16K). Call before using the framer!
473 void set_header_buffer_size(size_t header_buffer_size) {
474 header_buffer_size_ = header_buffer_size;
475 header_buffer_.reset(new char[header_buffer_size]);
476 }
477
478 static size_t header_data_chunk_max_size() {
479 return SpdyFramer::kHeaderDataChunkMaxSize;
480 }
481
482 SpdyFramer framer_;
483 bool use_compression_;
484
485 // Counters from the visitor callbacks.
486 int error_count_;
487 int syn_frame_count_;
488 int syn_reply_frame_count_;
489 int headers_frame_count_;
490 int push_promise_frame_count_;
491 int goaway_count_;
492 int setting_count_;
493 int settings_ack_sent_;
494 int settings_ack_received_;
495 int continuation_count_;
496 int altsvc_count_;
497 SpdyAltSvcIR test_altsvc_ir_;
498 SpdyStreamId last_window_update_stream_;
499 uint32 last_window_update_delta_;
500 SpdyStreamId last_push_promise_stream_;
501 SpdyStreamId last_push_promise_promised_stream_;
502 int data_bytes_;
503 int fin_frame_count_; // The count of RST_STREAM type frames received.
504 std::string fin_opaque_data_;
505 int fin_flag_count_; // The count of frames with the FIN flag set.
506 int zero_length_data_frame_count_; // The count of zero-length data frames.
507 int control_frame_header_data_count_; // The count of chunks received.
508 // The count of zero-length control frame header data chunks received.
509 int zero_length_control_frame_header_data_count_;
510 int data_frame_count_;
511 size_t last_payload_len_;
512 size_t last_frame_len_;
513
514 // Header block streaming state:
515 scoped_ptr<char[]> header_buffer_;
516 size_t header_buffer_length_;
517 size_t header_buffer_size_;
518 SpdyStreamId header_stream_id_;
519 SpdyFrameType header_control_type_;
520 bool header_buffer_valid_;
521 SpdyHeaderBlock headers_;
522 };
523
524 // Retrieves serialized headers from a HEADERS or SYN_STREAM frame.
525 base::StringPiece GetSerializedHeaders(const SpdyFrame* frame,
526 const SpdyFramer& framer) {
527 SpdyFrameReader reader(frame->data(), frame->size());
528 reader.Seek(2); // Seek past the frame length.
529 SpdyFrameType frame_type;
530 if (framer.protocol_version() > SPDY3) {
531 uint8 serialized_type;
532 reader.ReadUInt8(&serialized_type);
533 frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
534 serialized_type);
535 DCHECK_EQ(HEADERS, frame_type);
536 uint8 flags;
537 reader.ReadUInt8(&flags);
538 if (flags & HEADERS_FLAG_PRIORITY) {
539 frame_type = SYN_STREAM;
540 }
541 } else {
542 uint16 serialized_type;
543 reader.ReadUInt16(&serialized_type);
544 frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
545 serialized_type);
546 DCHECK(frame_type == HEADERS ||
547 frame_type == SYN_STREAM) << frame_type;
548 }
549
550 if (frame_type == SYN_STREAM) {
551 return StringPiece(frame->data() + framer.GetSynStreamMinimumSize(),
552 frame->size() - framer.GetSynStreamMinimumSize());
553 } else {
554 return StringPiece(frame->data() + framer.GetHeadersMinimumSize(),
555 frame->size() - framer.GetHeadersMinimumSize());
556 }
557 }
558
559 } // namespace test
560
561 } // namespace net
562
563 using net::test::SetFrameLength;
564 using net::test::SetFrameFlags;
565 using net::test::CompareCharArraysWithHexError;
566 using net::test::SpdyFramerTestUtil;
567 using net::test::TestSpdyVisitor;
568 using net::test::GetSerializedHeaders;
569
570 namespace net {
571
572 class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> {
573 protected:
574 virtual void SetUp() {
575 spdy_version_ = GetParam();
576 spdy_version_ch_ = static_cast<unsigned char>(
577 SpdyConstants::SerializeMajorVersion(spdy_version_));
578 }
579
580 void CompareFrame(const string& description,
581 const SpdyFrame& actual_frame,
582 const unsigned char* expected,
583 const int expected_len) {
584 const unsigned char* actual =
585 reinterpret_cast<const unsigned char*>(actual_frame.data());
586 CompareCharArraysWithHexError(
587 description, actual, actual_frame.size(), expected, expected_len);
588 }
589
590 void CompareFrames(const string& description,
591 const SpdyFrame& expected_frame,
592 const SpdyFrame& actual_frame) {
593 CompareCharArraysWithHexError(
594 description,
595 reinterpret_cast<const unsigned char*>(expected_frame.data()),
596 expected_frame.size(),
597 reinterpret_cast<const unsigned char*>(actual_frame.data()),
598 actual_frame.size());
599 }
600
601 // Returns true if the two header blocks have equivalent content.
602 bool CompareHeaderBlocks(const SpdyHeaderBlock* expected,
603 const SpdyHeaderBlock* actual) {
604 if (expected->size() != actual->size()) {
605 LOG(ERROR) << "Expected " << expected->size() << " headers; actually got "
606 << actual->size() << ".";
607 return false;
608 }
609 for (SpdyHeaderBlock::const_iterator it = expected->begin();
610 it != expected->end();
611 ++it) {
612 SpdyHeaderBlock::const_iterator it2 = actual->find(it->first);
613 if (it2 == actual->end()) {
614 LOG(ERROR) << "Expected header name '" << it->first << "'.";
615 return false;
616 }
617 if (it->second.compare(it2->second) != 0) {
618 LOG(ERROR) << "Expected header named '" << it->first
619 << "' to have a value of '" << it->second
620 << "'. The actual value received was '" << it2->second
621 << "'.";
622 return false;
623 }
624 }
625 return true;
626 }
627
628 bool IsSpdy2() { return spdy_version_ == SPDY2; }
629 bool IsSpdy3() { return spdy_version_ == SPDY3; }
630 bool IsSpdy4() { return spdy_version_ == SPDY4; }
631 bool IsSpdy5() { return spdy_version_ == SPDY5; }
632
633 // Version of SPDY protocol to be used.
634 SpdyMajorVersion spdy_version_;
635 unsigned char spdy_version_ch_;
636 };
637
638 // All tests are run with 3 different SPDY versions: SPDY/2, SPDY/3, SPDY/4.
639 INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
640 SpdyFramerTest,
641 ::testing::Values(SPDY2, SPDY3, SPDY4));
642
643 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
644 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
645 SpdyFramer framer(spdy_version_);
646 framer.set_enable_compression(false);
647
648 // Encode the header block into a SynStream frame.
649 SpdySynStreamIR syn_stream(1);
650 syn_stream.set_priority(1);
651 syn_stream.SetHeader("alpha", "beta");
652 syn_stream.SetHeader("gamma", "charlie");
653 syn_stream.SetHeader("cookie", "key1=value1; key2=value2");
654 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
655 EXPECT_TRUE(frame.get() != NULL);
656
657 TestSpdyVisitor visitor(spdy_version_);
658 visitor.use_compression_ = false;
659 visitor.SimulateInFramer(
660 reinterpret_cast<unsigned char*>(frame->data()),
661 frame->size());
662
663 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
664 EXPECT_TRUE(CompareHeaderBlocks(&syn_stream.name_value_block(),
665 &visitor.headers_));
666 }
667
668 // Test that if there's not a full frame, we fail to parse it.
669 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
670 SpdyFramer framer(spdy_version_);
671 framer.set_enable_compression(false);
672
673 // Encode the header block into a SynStream frame.
674 SpdySynStreamIR syn_stream(1);
675 syn_stream.set_priority(1);
676 syn_stream.SetHeader("alpha", "beta");
677 syn_stream.SetHeader("gamma", "charlie");
678 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
679 EXPECT_TRUE(frame.get() != NULL);
680
681 TestSpdyVisitor visitor(spdy_version_);
682 visitor.use_compression_ = false;
683 visitor.SimulateInFramer(
684 reinterpret_cast<unsigned char*>(frame->data()),
685 frame->size() - 2);
686
687 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
688 EXPECT_EQ(0u, visitor.headers_.size());
689 }
690
691 // Test that if we receive a SYN_REPLY with stream ID zero, we signal an error
692 // (but don't crash).
693 TEST_P(SpdyFramerTest, SynReplyWithStreamIdZero) {
694 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
695 SpdyFramer framer(spdy_version_);
696 framer.set_visitor(&visitor);
697
698 SpdySynReplyIR syn_reply(0);
699 syn_reply.SetHeader("alpha", "beta");
700 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeSynReply(syn_reply));
701 ASSERT_TRUE(frame.get() != NULL);
702
703 // We shouldn't have to read the whole frame before we signal an error.
704 EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
705 EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
706 EXPECT_TRUE(framer.HasError());
707 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
708 << SpdyFramer::ErrorCodeToString(framer.error_code());
709 }
710
711 // Test that if we receive a HEADERS with stream ID zero, we signal an error
712 // (but don't crash).
713 TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) {
714 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
715 SpdyFramer framer(spdy_version_);
716 framer.set_visitor(&visitor);
717
718 SpdyHeadersIR headers_ir(0);
719 headers_ir.SetHeader("alpha", "beta");
720 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeHeaders(headers_ir));
721 ASSERT_TRUE(frame.get() != NULL);
722
723 // We shouldn't have to read the whole frame before we signal an error.
724 EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
725 EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
726 EXPECT_TRUE(framer.HasError());
727 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
728 << SpdyFramer::ErrorCodeToString(framer.error_code());
729 }
730
731 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
732 // error (but don't crash).
733 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
734 if (spdy_version_ <= SPDY3) {
735 return;
736 }
737
738 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
739 SpdyFramer framer(spdy_version_);
740 framer.set_visitor(&visitor);
741
742 SpdyPushPromiseIR push_promise(0, 4);
743 push_promise.SetHeader("alpha", "beta");
744 scoped_ptr<SpdySerializedFrame> frame(
745 framer.SerializePushPromise(push_promise));
746 ASSERT_TRUE(frame.get() != NULL);
747
748 // We shouldn't have to read the whole frame before we signal an error.
749 EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
750 EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
751 EXPECT_TRUE(framer.HasError());
752 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
753 << SpdyFramer::ErrorCodeToString(framer.error_code());
754 }
755
756 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
757 // signal an error (but don't crash).
758 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
759 if (spdy_version_ <= SPDY3) {
760 return;
761 }
762
763 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
764 SpdyFramer framer(spdy_version_);
765 framer.set_visitor(&visitor);
766
767 SpdyPushPromiseIR push_promise(3, 0);
768 push_promise.SetHeader("alpha", "beta");
769 scoped_ptr<SpdySerializedFrame> frame(
770 framer.SerializePushPromise(push_promise));
771 ASSERT_TRUE(frame.get() != NULL);
772
773 // We shouldn't have to read the whole frame before we signal an error.
774 EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
775 EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
776 EXPECT_TRUE(framer.HasError());
777 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
778 << SpdyFramer::ErrorCodeToString(framer.error_code());
779 }
780
781 TEST_P(SpdyFramerTest, DuplicateHeader) {
782 if (spdy_version_ > SPDY3) {
783 // TODO(jgraettinger): Punting on this because we haven't determined
784 // whether duplicate HPACK headers other than Cookie are an error.
785 // If they are, this will need to be updated to use HpackOutputStream.
786 return;
787 }
788 SpdyFramer framer(spdy_version_);
789 // Frame builder with plentiful buffer size.
790 SpdyFrameBuilder frame(1024, spdy_version_);
791 if (spdy_version_ <= SPDY3) {
792 frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
793 frame.WriteUInt32(3); // stream_id
794 frame.WriteUInt32(0); // associated stream id
795 frame.WriteUInt16(0); // Priority.
796 } else {
797 frame.BeginNewFrame(framer, HEADERS, HEADERS_FLAG_PRIORITY, 3);
798 frame.WriteUInt32(framer.GetHighestPriority());
799 }
800
801 if (IsSpdy2()) {
802 frame.WriteUInt16(2); // Number of headers.
803 frame.WriteString("name");
804 frame.WriteString("value1");
805 frame.WriteString("name");
806 frame.WriteString("value2");
807 } else {
808 frame.WriteUInt32(2); // Number of headers.
809 frame.WriteStringPiece32("name");
810 frame.WriteStringPiece32("value1");
811 frame.WriteStringPiece32("name");
812 frame.WriteStringPiece32("value2");
813 }
814 // write the length
815 frame.RewriteLength(framer);
816
817 SpdyHeaderBlock new_headers;
818 framer.set_enable_compression(false);
819 scoped_ptr<SpdyFrame> control_frame(frame.take());
820 base::StringPiece serialized_headers =
821 GetSerializedHeaders(control_frame.get(), framer);
822 // This should fail because duplicate headers are verboten by the spec.
823 EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
824 serialized_headers.size(),
825 &new_headers));
826 }
827
828 TEST_P(SpdyFramerTest, MultiValueHeader) {
829 SpdyFramer framer(spdy_version_);
830 // Frame builder with plentiful buffer size.
831 SpdyFrameBuilder frame(1024, spdy_version_);
832 if (spdy_version_ <= SPDY3) {
833 frame.WriteControlFrameHeader(framer, SYN_STREAM, CONTROL_FLAG_NONE);
834 frame.WriteUInt32(3); // stream_id
835 frame.WriteUInt32(0); // associated stream id
836 frame.WriteUInt16(0); // Priority.
837 } else {
838 frame.BeginNewFrame(framer,
839 HEADERS,
840 HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS,
841 3);
842 frame.WriteUInt32(0); // Priority exclusivity and dependent stream.
843 frame.WriteUInt8(255); // Priority weight.
844 }
845
846 string value("value1\0value2", 13);
847 if (IsSpdy2()) {
848 frame.WriteUInt16(1); // Number of headers.
849 frame.WriteString("name");
850 frame.WriteString(value);
851 } else if (spdy_version_ > SPDY3) {
852 // TODO(jgraettinger): If this pattern appears again, move to test class.
853 std::map<string, string> header_set;
854 header_set["name"] = value;
855 string buffer;
856 HpackEncoder encoder(ObtainHpackHuffmanTable());
857 encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
858 frame.WriteBytes(&buffer[0], buffer.size());
859 } else {
860 frame.WriteUInt32(1); // Number of headers.
861 frame.WriteStringPiece32("name");
862 frame.WriteStringPiece32(value);
863 }
864 // write the length
865 frame.RewriteLength(framer);
866
867 framer.set_enable_compression(false);
868 scoped_ptr<SpdyFrame> control_frame(frame.take());
869
870 TestSpdyVisitor visitor(spdy_version_);
871 visitor.use_compression_ = false;
872 visitor.SimulateInFramer(
873 reinterpret_cast<unsigned char*>(control_frame->data()),
874 control_frame->size());
875
876 EXPECT_THAT(visitor.headers_, ElementsAre(
877 Pair("name", value)));
878 }
879
880 TEST_P(SpdyFramerTest, BasicCompression) {
881 if (spdy_version_ > SPDY3) {
882 // Deflate compression doesn't apply to HPACK.
883 return;
884 }
885 scoped_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor(spdy_version_));
886 SpdyFramer framer(spdy_version_);
887 framer.set_debug_visitor(visitor.get());
888 SpdySynStreamIR syn_stream(1);
889 syn_stream.set_priority(1);
890 syn_stream.SetHeader("server", "SpdyServer 1.0");
891 syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
892 syn_stream.SetHeader("status", "200");
893 syn_stream.SetHeader("version", "HTTP/1.1");
894 syn_stream.SetHeader("content-type", "text/html");
895 syn_stream.SetHeader("content-length", "12");
896 scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
897 size_t uncompressed_size1 = visitor->last_payload_len_;
898 size_t compressed_size1 =
899 visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
900 if (IsSpdy2()) {
901 EXPECT_EQ(139u, uncompressed_size1);
902 #if defined(USE_SYSTEM_ZLIB)
903 EXPECT_EQ(155u, compressed_size1);
904 #else // !defined(USE_SYSTEM_ZLIB)
905 EXPECT_EQ(135u, compressed_size1);
906 #endif // !defined(USE_SYSTEM_ZLIB)
907 } else {
908 EXPECT_EQ(165u, uncompressed_size1);
909 #if defined(USE_SYSTEM_ZLIB)
910 EXPECT_EQ(181u, compressed_size1);
911 #else // !defined(USE_SYSTEM_ZLIB)
912 EXPECT_EQ(117u, compressed_size1);
913 #endif // !defined(USE_SYSTEM_ZLIB)
914 }
915 scoped_ptr<SpdyFrame> frame2(framer.SerializeSynStream(syn_stream));
916 size_t uncompressed_size2 = visitor->last_payload_len_;
917 size_t compressed_size2 =
918 visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
919
920 // Expect the second frame to be more compact than the first.
921 EXPECT_LE(frame2->size(), frame1->size());
922
923 // Decompress the first frame
924 scoped_ptr<SpdyFrame> frame3(SpdyFramerTestUtil::DecompressFrame(
925 &framer, *frame1.get()));
926
927 // Decompress the second frame
928 visitor.reset(new TestSpdyVisitor(spdy_version_));
929 framer.set_debug_visitor(visitor.get());
930 scoped_ptr<SpdyFrame> frame4(SpdyFramerTestUtil::DecompressFrame(
931 &framer, *frame2.get()));
932 size_t uncompressed_size4 =
933 frame4->size() - framer.GetSynStreamMinimumSize();
934 size_t compressed_size4 =
935 visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
936 if (IsSpdy2()) {
937 EXPECT_EQ(139u, uncompressed_size4);
938 #if defined(USE_SYSTEM_ZLIB)
939 EXPECT_EQ(149u, compressed_size4);
940 #else // !defined(USE_SYSTEM_ZLIB)
941 EXPECT_EQ(101u, compressed_size4);
942 #endif // !defined(USE_SYSTEM_ZLIB)
943 } else {
944 EXPECT_EQ(165u, uncompressed_size4);
945 #if defined(USE_SYSTEM_ZLIB)
946 EXPECT_EQ(175u, compressed_size4);
947 #else // !defined(USE_SYSTEM_ZLIB)
948 EXPECT_EQ(102u, compressed_size4);
949 #endif // !defined(USE_SYSTEM_ZLIB)
950 }
951
952 EXPECT_EQ(uncompressed_size1, uncompressed_size2);
953 EXPECT_EQ(uncompressed_size1, uncompressed_size4);
954 EXPECT_EQ(compressed_size2, compressed_size4);
955
956 // Expect frames 3 & 4 to be the same.
957 CompareFrames("Uncompressed SYN_STREAM", *frame3, *frame4);
958
959 // Expect frames 3 to be the same as a uncompressed frame created
960 // from scratch.
961 framer.set_enable_compression(false);
962 scoped_ptr<SpdyFrame> uncompressed_frame(
963 framer.SerializeSynStream(syn_stream));
964 CompareFrames("Uncompressed SYN_STREAM", *frame3, *uncompressed_frame);
965 }
966
967 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
968 // See crbug.com/172383
969 SpdySynStreamIR syn_stream(1);
970 syn_stream.SetHeader("server", "SpdyServer 1.0");
971 syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
972 syn_stream.SetHeader("status", "200");
973 syn_stream.SetHeader("version", "HTTP/1.1");
974 syn_stream.SetHeader("content-type", "text/html");
975 syn_stream.SetHeader("content-length", "12");
976 syn_stream.SetHeader("x-empty-header", "");
977
978 SpdyFramer framer(spdy_version_);
979 framer.set_enable_compression(true);
980 scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
981 }
982
983 TEST_P(SpdyFramerTest, Basic) {
984 const unsigned char kV2Input[] = {
985 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
986 0x00, 0x00, 0x00, 0x14,
987 0x00, 0x00, 0x00, 0x01,
988 0x00, 0x00, 0x00, 0x00,
989 0x00, 0x00, 0x00, 0x01,
990 0x00, 0x02, 'h', 'h',
991 0x00, 0x02, 'v', 'v',
992
993 0x80, spdy_version_ch_, 0x00, 0x08, // HEADERS on Stream #1
994 0x00, 0x00, 0x00, 0x18,
995 0x00, 0x00, 0x00, 0x01,
996 0x00, 0x00, 0x00, 0x02,
997 0x00, 0x02, 'h', '2',
998 0x00, 0x02, 'v', '2',
999 0x00, 0x02, 'h', '3',
1000 0x00, 0x02, 'v', '3',
1001
1002 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1003 0x00, 0x00, 0x00, 0x0c,
1004 0xde, 0xad, 0xbe, 0xef,
1005 0xde, 0xad, 0xbe, 0xef,
1006 0xde, 0xad, 0xbe, 0xef,
1007
1008 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #3
1009 0x00, 0x00, 0x00, 0x0c,
1010 0x00, 0x00, 0x00, 0x03,
1011 0x00, 0x00, 0x00, 0x00,
1012 0x00, 0x00, 0x00, 0x00,
1013
1014 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
1015 0x00, 0x00, 0x00, 0x08,
1016 0xde, 0xad, 0xbe, 0xef,
1017 0xde, 0xad, 0xbe, 0xef,
1018
1019 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1020 0x00, 0x00, 0x00, 0x04,
1021 0xde, 0xad, 0xbe, 0xef,
1022
1023 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #1
1024 0x00, 0x00, 0x00, 0x08,
1025 0x00, 0x00, 0x00, 0x01,
1026 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL
1027
1028 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
1029 0x00, 0x00, 0x00, 0x00,
1030
1031 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #3
1032 0x00, 0x00, 0x00, 0x08,
1033 0x00, 0x00, 0x00, 0x03,
1034 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL
1035 };
1036
1037 const unsigned char kV3Input[] = {
1038 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
1039 0x00, 0x00, 0x00, 0x1a,
1040 0x00, 0x00, 0x00, 0x01,
1041 0x00, 0x00, 0x00, 0x00,
1042 0x00, 0x00, 0x00, 0x00,
1043 0x00, 0x01, 0x00, 0x00,
1044 0x00, 0x02, 'h', 'h',
1045 0x00, 0x00, 0x00, 0x02,
1046 'v', 'v',
1047
1048 0x80, spdy_version_ch_, 0x00, 0x08, // HEADERS on Stream #1
1049 0x00, 0x00, 0x00, 0x20,
1050 0x00, 0x00, 0x00, 0x01,
1051 0x00, 0x00, 0x00, 0x02,
1052 0x00, 0x00, 0x00, 0x02,
1053 'h', '2',
1054 0x00, 0x00, 0x00, 0x02,
1055 'v', '2', 0x00, 0x00,
1056 0x00, 0x02, 'h', '3',
1057 0x00, 0x00, 0x00, 0x02,
1058 'v', '3',
1059
1060 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1061 0x00, 0x00, 0x00, 0x0c,
1062 0xde, 0xad, 0xbe, 0xef,
1063 0xde, 0xad, 0xbe, 0xef,
1064 0xde, 0xad, 0xbe, 0xef,
1065
1066 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #3
1067 0x00, 0x00, 0x00, 0x0e,
1068 0x00, 0x00, 0x00, 0x03,
1069 0x00, 0x00, 0x00, 0x00,
1070 0x00, 0x00, 0x00, 0x00,
1071 0x00, 0x00,
1072
1073 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
1074 0x00, 0x00, 0x00, 0x08,
1075 0xde, 0xad, 0xbe, 0xef,
1076 0xde, 0xad, 0xbe, 0xef,
1077
1078 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1079 0x00, 0x00, 0x00, 0x04,
1080 0xde, 0xad, 0xbe, 0xef,
1081
1082 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #1
1083 0x00, 0x00, 0x00, 0x08,
1084 0x00, 0x00, 0x00, 0x01,
1085 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL
1086
1087 0x00, 0x00, 0x00, 0x03, // DATA on Stream #3
1088 0x00, 0x00, 0x00, 0x00,
1089
1090 0x80, spdy_version_ch_, 0x00, 0x03, // RST_STREAM on Stream #3
1091 0x00, 0x00, 0x00, 0x08,
1092 0x00, 0x00, 0x00, 0x03,
1093 0x00, 0x00, 0x00, 0x05, // RST_STREAM_CANCEL
1094 };
1095
1096 // SYN_STREAM doesn't exist in SPDY4, so instead we send
1097 // HEADERS frames with PRIORITY and END_HEADERS set.
1098 const unsigned char kV4Input[] = {
1099 0x00, 0x05, 0x01, 0x24, // HEADERS: PRIORITY | END_HEADERS
1100 0x00, 0x00, 0x00, 0x01, // Stream 1
1101 0x00, 0x00, 0x00, 0x00, // Priority 0
1102 0x82, // :method: GET
1103
1104 0x00, 0x01, 0x01, 0x04, // HEADERS: END_HEADERS
1105 0x00, 0x00, 0x00, 0x01, // Stream 1
1106 0x8c, // :status: 200
1107
1108 0x00, 0x0c, 0x00, 0x00, // DATA on Stream #1
1109 0x00, 0x00, 0x00, 0x01,
1110 0xde, 0xad, 0xbe, 0xef,
1111 0xde, 0xad, 0xbe, 0xef,
1112 0xde, 0xad, 0xbe, 0xef,
1113
1114 0x00, 0x05, 0x01, 0x24, // HEADERS: PRIORITY | END_HEADERS
1115 0x00, 0x00, 0x00, 0x03, // Stream 3
1116 0x00, 0x00, 0x00, 0x00, // Priority 0
1117 0x82, // :method: GET
1118
1119 0x00, 0x08, 0x00, 0x00, // DATA on Stream #3
1120 0x00, 0x00, 0x00, 0x03,
1121 0xde, 0xad, 0xbe, 0xef,
1122 0xde, 0xad, 0xbe, 0xef,
1123
1124 0x00, 0x04, 0x00, 0x00, // DATA on Stream #1
1125 0x00, 0x00, 0x00, 0x01,
1126 0xde, 0xad, 0xbe, 0xef,
1127
1128 0x00, 0x04, 0x03, 0x00, // RST_STREAM on Stream #1
1129 0x00, 0x00, 0x00, 0x01,
1130 0x00, 0x00, 0x00, 0x08, // RST_STREAM_CANCEL
1131
1132 0x00, 0x00, 0x00, 0x00, // DATA on Stream #3
1133 0x00, 0x00, 0x00, 0x03,
1134
1135 0x00, 0x0f, 0x03, 0x00, // RST_STREAM on Stream #3
1136 0x00, 0x00, 0x00, 0x03,
1137 0x00, 0x00, 0x00, 0x08, // RST_STREAM_CANCEL
1138 0x52, 0x45, 0x53, 0x45, // opaque data
1139 0x54, 0x53, 0x54, 0x52,
1140 0x45, 0x41, 0x4d,
1141 };
1142
1143 TestSpdyVisitor visitor(spdy_version_);
1144 if (IsSpdy2()) {
1145 visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
1146 } else if (IsSpdy3()) {
1147 visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
1148 } else {
1149 visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
1150 }
1151
1152 EXPECT_EQ(2, visitor.syn_frame_count_);
1153 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
1154 EXPECT_EQ(1, visitor.headers_frame_count_);
1155 EXPECT_EQ(24, visitor.data_bytes_);
1156
1157 EXPECT_EQ(0, visitor.error_count_);
1158 EXPECT_EQ(2, visitor.fin_frame_count_);
1159
1160 if (IsSpdy4()) {
1161 base::StringPiece reset_stream = "RESETSTREAM";
1162 EXPECT_EQ(reset_stream, visitor.fin_opaque_data_);
1163 } else {
1164 EXPECT_TRUE(visitor.fin_opaque_data_.empty());
1165 }
1166
1167 EXPECT_EQ(0, visitor.fin_flag_count_);
1168 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
1169 EXPECT_EQ(4, visitor.data_frame_count_);
1170 visitor.fin_opaque_data_.clear();
1171 }
1172
1173 // Test that the FIN flag on a data frame signifies EOF.
1174 TEST_P(SpdyFramerTest, FinOnDataFrame) {
1175 const unsigned char kV2Input[] = {
1176 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
1177 0x00, 0x00, 0x00, 0x14,
1178 0x00, 0x00, 0x00, 0x01,
1179 0x00, 0x00, 0x00, 0x00,
1180 0x00, 0x00, 0x00, 0x01,
1181 0x00, 0x02, 'h', 'h',
1182 0x00, 0x02, 'v', 'v',
1183
1184 0x80, spdy_version_ch_, 0x00, 0x02, // SYN REPLY Stream #1
1185 0x00, 0x00, 0x00, 0x10,
1186 0x00, 0x00, 0x00, 0x01,
1187 0x00, 0x00, 0x00, 0x01,
1188 0x00, 0x02, 'a', 'a',
1189 0x00, 0x02, 'b', 'b',
1190
1191 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1192 0x00, 0x00, 0x00, 0x0c,
1193 0xde, 0xad, 0xbe, 0xef,
1194 0xde, 0xad, 0xbe, 0xef,
1195 0xde, 0xad, 0xbe, 0xef,
1196
1197 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1, with EOF
1198 0x01, 0x00, 0x00, 0x04,
1199 0xde, 0xad, 0xbe, 0xef,
1200 };
1201 const unsigned char kV3Input[] = {
1202 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
1203 0x00, 0x00, 0x00, 0x1a,
1204 0x00, 0x00, 0x00, 0x01,
1205 0x00, 0x00, 0x00, 0x00,
1206 0x00, 0x00, 0x00, 0x00,
1207 0x00, 0x01, 0x00, 0x00,
1208 0x00, 0x02, 'h', 'h',
1209 0x00, 0x00, 0x00, 0x02,
1210 'v', 'v',
1211
1212 0x80, spdy_version_ch_, 0x00, 0x02, // SYN REPLY Stream #1
1213 0x00, 0x00, 0x00, 0x14,
1214 0x00, 0x00, 0x00, 0x01,
1215 0x00, 0x00, 0x00, 0x01,
1216 0x00, 0x00, 0x00, 0x02,
1217 'a', 'a', 0x00, 0x00,
1218 0x00, 0x02, 'b', 'b',
1219
1220 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
1221 0x00, 0x00, 0x00, 0x0c,
1222 0xde, 0xad, 0xbe, 0xef,
1223 0xde, 0xad, 0xbe, 0xef,
1224 0xde, 0xad, 0xbe, 0xef,
1225
1226 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1, with EOF
1227 0x01, 0x00, 0x00, 0x04,
1228 0xde, 0xad, 0xbe, 0xef,
1229 };
1230
1231 // SYN_STREAM and SYN_REPLY don't exist in SPDY4, so instead we send
1232 // HEADERS frames with PRIORITY(SYN_STREAM only) and END_HEADERS set.
1233 const unsigned char kV4Input[] = {
1234 0x00, 0x05, 0x01, 0x24, // HEADERS: PRIORITY | END_HEADERS
1235 0x00, 0x00, 0x00, 0x01, // Stream 1
1236 0x00, 0x00, 0x00, 0x00, // Priority 0
1237 0x82, // :method: GET
1238
1239 0x00, 0x01, 0x01, 0x04, // HEADERS: END_HEADERS
1240 0x00, 0x00, 0x00, 0x01, // Stream 1
1241 0x8c, // :status: 200
1242
1243 0x00, 0x0c, 0x00, 0x00, // DATA on Stream #1
1244 0x00, 0x00, 0x00, 0x01,
1245 0xde, 0xad, 0xbe, 0xef,
1246 0xde, 0xad, 0xbe, 0xef,
1247 0xde, 0xad, 0xbe, 0xef,
1248
1249 0x00, 0x04, 0x00, 0x01, // DATA on Stream #1, with FIN
1250 0x00, 0x00, 0x00, 0x01,
1251 0xde, 0xad, 0xbe, 0xef,
1252 };
1253
1254 TestSpdyVisitor visitor(spdy_version_);
1255 if (IsSpdy2()) {
1256 visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
1257 } else if (IsSpdy3()) {
1258 visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
1259 } else {
1260 visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
1261 }
1262
1263 EXPECT_EQ(0, visitor.error_count_);
1264 EXPECT_EQ(1, visitor.syn_frame_count_);
1265 if (IsSpdy4()) {
1266 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
1267 EXPECT_EQ(1, visitor.headers_frame_count_);
1268 } else {
1269 EXPECT_EQ(1, visitor.syn_reply_frame_count_);
1270 EXPECT_EQ(0, visitor.headers_frame_count_);
1271 }
1272 EXPECT_EQ(16, visitor.data_bytes_);
1273 EXPECT_EQ(0, visitor.fin_frame_count_);
1274 EXPECT_EQ(0, visitor.fin_flag_count_);
1275 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
1276 EXPECT_EQ(2, visitor.data_frame_count_);
1277 }
1278
1279 // Test that the FIN flag on a SYN reply frame signifies EOF.
1280 TEST_P(SpdyFramerTest, FinOnSynReplyFrame) {
1281 const unsigned char kV2Input[] = {
1282 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
1283 0x00, 0x00, 0x00, 0x14,
1284 0x00, 0x00, 0x00, 0x01,
1285 0x00, 0x00, 0x00, 0x00,
1286 0x00, 0x00, 0x00, 0x01,
1287 0x00, 0x02, 'h', 'h',
1288 0x00, 0x02, 'v', 'v',
1289
1290 0x80, spdy_version_ch_, 0x00, 0x02, // SYN REPLY Stream #1
1291 0x01, 0x00, 0x00, 0x10,
1292 0x00, 0x00, 0x00, 0x01,
1293 0x00, 0x00, 0x00, 0x01,
1294 0x00, 0x02, 'a', 'a',
1295 0x00, 0x02, 'b', 'b',
1296 };
1297 const unsigned char kV3Input[] = {
1298 0x80, spdy_version_ch_, 0x00, 0x01, // SYN Stream #1
1299 0x00, 0x00, 0x00, 0x1a,
1300 0x00, 0x00, 0x00, 0x01,
1301 0x00, 0x00, 0x00, 0x00,
1302 0x00, 0x00, 0x00, 0x00,
1303 0x00, 0x01, 0x00, 0x00,
1304 0x00, 0x02, 'h', 'h',
1305 0x00, 0x00, 0x00, 0x02,
1306 'v', 'v',
1307
1308 0x80, spdy_version_ch_, 0x00, 0x02, // SYN REPLY Stream #1
1309 0x01, 0x00, 0x00, 0x14,
1310 0x00, 0x00, 0x00, 0x01,
1311 0x00, 0x00, 0x00, 0x01,
1312 0x00, 0x00, 0x00, 0x02,
1313 'a', 'a', 0x00, 0x00,
1314 0x00, 0x02, 'b', 'b',
1315 };
1316
1317 // SYN_STREAM and SYN_REPLY don't exist in SPDY4, so instead we send
1318 // HEADERS frames with PRIORITY(SYN_STREAM only) and END_HEADERS set.
1319 const unsigned char kV4Input[] = {
1320 0x00, 0x05, 0x01, 0x24, // HEADERS: PRIORITY | END_HEADERS
1321 0x00, 0x00, 0x00, 0x01, // Stream 1
1322 0x00, 0x00, 0x00, 0x00, // Priority 0
1323 0x82, // :method: GET
1324
1325 0x00, 0x01, 0x01, 0x05, // HEADERS: FIN | END_HEADERS
1326 0x00, 0x00, 0x00, 0x01, // Stream 1
1327 0x8c, // :status: 200
1328 };
1329
1330 TestSpdyVisitor visitor(spdy_version_);
1331 if (IsSpdy2()) {
1332 visitor.SimulateInFramer(kV2Input, sizeof(kV2Input));
1333 } else if (IsSpdy3()) {
1334 visitor.SimulateInFramer(kV3Input, sizeof(kV3Input));
1335 } else {
1336 visitor.SimulateInFramer(kV4Input, sizeof(kV4Input));
1337 }
1338
1339 EXPECT_EQ(0, visitor.error_count_);
1340 EXPECT_EQ(1, visitor.syn_frame_count_);
1341 if (IsSpdy4()) {
1342 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
1343 EXPECT_EQ(1, visitor.headers_frame_count_);
1344 } else {
1345 EXPECT_EQ(1, visitor.syn_reply_frame_count_);
1346 EXPECT_EQ(0, visitor.headers_frame_count_);
1347 }
1348 EXPECT_EQ(0, visitor.data_bytes_);
1349 EXPECT_EQ(0, visitor.fin_frame_count_);
1350 EXPECT_EQ(1, visitor.fin_flag_count_);
1351 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
1352 EXPECT_EQ(0, visitor.data_frame_count_);
1353 }
1354
1355 TEST_P(SpdyFramerTest, HeaderCompression) {
1356 if (spdy_version_ > SPDY3) {
1357 // Deflate compression doesn't apply to HPACK.
1358 return;
1359 }
1360 SpdyFramer send_framer(spdy_version_);
1361 SpdyFramer recv_framer(spdy_version_);
1362
1363 send_framer.set_enable_compression(true);
1364 recv_framer.set_enable_compression(true);
1365
1366 const char kHeader1[] = "header1";
1367 const char kHeader2[] = "header2";
1368 const char kHeader3[] = "header3";
1369 const char kValue1[] = "value1";
1370 const char kValue2[] = "value2";
1371 const char kValue3[] = "value3";
1372
1373 // SYN_STREAM #1
1374 SpdyHeaderBlock block;
1375 block[kHeader1] = kValue1;
1376 block[kHeader2] = kValue2;
1377 SpdySynStreamIR syn_ir_1(1);
1378 syn_ir_1.set_name_value_block(block);
1379 scoped_ptr<SpdyFrame> syn_frame_1(send_framer.SerializeFrame(syn_ir_1));
1380 EXPECT_TRUE(syn_frame_1.get() != NULL);
1381
1382 // SYN_STREAM #2
1383 block[kHeader3] = kValue3;
1384 SpdySynStreamIR syn_stream(3);
1385 syn_stream.set_name_value_block(block);
1386 scoped_ptr<SpdyFrame> syn_frame_2(send_framer.SerializeSynStream(syn_stream));
1387 EXPECT_TRUE(syn_frame_2.get() != NULL);
1388
1389 // Now start decompressing
1390 scoped_ptr<SpdyFrame> decompressed;
1391 scoped_ptr<SpdyFrame> uncompressed;
1392 base::StringPiece serialized_headers;
1393 SpdyHeaderBlock decompressed_headers;
1394
1395 // Decompress SYN_STREAM #1
1396 decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
1397 &recv_framer, *syn_frame_1.get()));
1398 EXPECT_TRUE(decompressed.get() != NULL);
1399 serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
1400 EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
1401 serialized_headers.size(),
1402 &decompressed_headers));
1403 EXPECT_EQ(2u, decompressed_headers.size());
1404 EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
1405 EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
1406
1407 // Decompress SYN_STREAM #2
1408 decompressed.reset(SpdyFramerTestUtil::DecompressFrame(
1409 &recv_framer, *syn_frame_2.get()));
1410 EXPECT_TRUE(decompressed.get() != NULL);
1411 serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
1412 decompressed_headers.clear();
1413 EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
1414 serialized_headers.size(),
1415 &decompressed_headers));
1416 EXPECT_EQ(3u, decompressed_headers.size());
1417 EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
1418 EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
1419 EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
1420 }
1421
1422 // Verify we don't leak when we leave streams unclosed
1423 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressors) {
1424 SpdyFramer send_framer(spdy_version_);
1425
1426 send_framer.set_enable_compression(true);
1427
1428 const char kHeader1[] = "header1";
1429 const char kHeader2[] = "header2";
1430 const char kValue1[] = "value1";
1431 const char kValue2[] = "value2";
1432
1433 SpdySynStreamIR syn_stream(1);
1434 syn_stream.SetHeader(kHeader1, kValue1);
1435 syn_stream.SetHeader(kHeader2, kValue2);
1436 scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
1437 EXPECT_TRUE(syn_frame.get() != NULL);
1438
1439 StringPiece bytes = "this is a test test test test test!";
1440 SpdyDataIR data_ir(1, bytes);
1441 data_ir.set_fin(true);
1442 scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
1443 EXPECT_TRUE(send_frame.get() != NULL);
1444
1445 // Run the inputs through the framer.
1446 TestSpdyVisitor visitor(spdy_version_);
1447 visitor.use_compression_ = true;
1448 const unsigned char* data;
1449 data = reinterpret_cast<const unsigned char*>(syn_frame->data());
1450 visitor.SimulateInFramer(data, syn_frame->size());
1451 data = reinterpret_cast<const unsigned char*>(send_frame->data());
1452 visitor.SimulateInFramer(data, send_frame->size());
1453
1454 EXPECT_EQ(0, visitor.error_count_);
1455 EXPECT_EQ(1, visitor.syn_frame_count_);
1456 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
1457 EXPECT_EQ(0, visitor.headers_frame_count_);
1458 EXPECT_EQ(bytes.size(), static_cast<unsigned>(visitor.data_bytes_));
1459 EXPECT_EQ(0, visitor.fin_frame_count_);
1460 EXPECT_EQ(0, visitor.fin_flag_count_);
1461 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
1462 EXPECT_EQ(1, visitor.data_frame_count_);
1463 }
1464
1465 // Verify we can decompress the stream even if handed over to the
1466 // framer 1 byte at a time.
1467 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
1468 SpdyFramer send_framer(spdy_version_);
1469
1470 send_framer.set_enable_compression(true);
1471
1472 const char kHeader1[] = "header1";
1473 const char kHeader2[] = "header2";
1474 const char kValue1[] = "value1";
1475 const char kValue2[] = "value2";
1476
1477 SpdySynStreamIR syn_stream(1);
1478 syn_stream.SetHeader(kHeader1, kValue1);
1479 syn_stream.SetHeader(kHeader2, kValue2);
1480 scoped_ptr<SpdyFrame> syn_frame(send_framer.SerializeSynStream(syn_stream));
1481 EXPECT_TRUE(syn_frame.get() != NULL);
1482
1483 const char bytes[] = "this is a test test test test test!";
1484 SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
1485 data_ir.set_fin(true);
1486 scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
1487 EXPECT_TRUE(send_frame.get() != NULL);
1488
1489 // Run the inputs through the framer.
1490 TestSpdyVisitor visitor(spdy_version_);
1491 visitor.use_compression_ = true;
1492 const unsigned char* data;
1493 data = reinterpret_cast<const unsigned char*>(syn_frame->data());
1494 for (size_t idx = 0; idx < syn_frame->size(); ++idx) {
1495 visitor.SimulateInFramer(data + idx, 1);
1496 ASSERT_EQ(0, visitor.error_count_);
1497 }
1498 data = reinterpret_cast<const unsigned char*>(send_frame->data());
1499 for (size_t idx = 0; idx < send_frame->size(); ++idx) {
1500 visitor.SimulateInFramer(data + idx, 1);
1501 ASSERT_EQ(0, visitor.error_count_);
1502 }
1503
1504 EXPECT_EQ(0, visitor.error_count_);
1505 EXPECT_EQ(1, visitor.syn_frame_count_);
1506 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
1507 EXPECT_EQ(0, visitor.headers_frame_count_);
1508 EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
1509 EXPECT_EQ(0, visitor.fin_frame_count_);
1510 EXPECT_EQ(0, visitor.fin_flag_count_);
1511 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
1512 EXPECT_EQ(1, visitor.data_frame_count_);
1513 }
1514
1515 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
1516 SpdyFramer framer(spdy_version_);
1517 scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
1518 SpdyWindowUpdateIR(1, 0x12345678)));
1519
1520 const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
1521 const unsigned char kV3FrameData[] = { // Also applies for V2.
1522 0x80, spdy_version_ch_, 0x00, 0x09,
1523 0x00, 0x00, 0x00, 0x08,
1524 0x00, 0x00, 0x00, 0x01,
1525 0x12, 0x34, 0x56, 0x78
1526 };
1527 const unsigned char kV4FrameData[] = {
1528 0x00, 0x04, 0x08, 0x00,
1529 0x00, 0x00, 0x00, 0x01,
1530 0x12, 0x34, 0x56, 0x78
1531 };
1532
1533 if (IsSpdy4()) {
1534 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1535 } else {
1536 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1537 }
1538 }
1539
1540 TEST_P(SpdyFramerTest, CreateDataFrame) {
1541 SpdyFramer framer(spdy_version_);
1542
1543 {
1544 const char kDescription[] = "'hello' data frame, no FIN";
1545 const unsigned char kV3FrameData[] = { // Also applies for V2.
1546 0x00, 0x00, 0x00, 0x01,
1547 0x00, 0x00, 0x00, 0x05,
1548 'h', 'e', 'l', 'l',
1549 'o'
1550 };
1551 const unsigned char kV4FrameData[] = {
1552 0x00, 0x05, 0x00, 0x00,
1553 0x00, 0x00, 0x00, 0x01,
1554 'h', 'e', 'l', 'l',
1555 'o'
1556 };
1557 const char bytes[] = "hello";
1558
1559 SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
1560 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1561 if (IsSpdy4()) {
1562 CompareFrame(
1563 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1564 } else {
1565 CompareFrame(
1566 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1567 }
1568
1569 SpdyDataIR data_header_ir(1);
1570 data_header_ir.SetDataShallow(base::StringPiece(bytes, strlen(bytes)));
1571 frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(
1572 data_header_ir));
1573 CompareCharArraysWithHexError(
1574 kDescription,
1575 reinterpret_cast<const unsigned char*>(frame->data()),
1576 framer.GetDataFrameMinimumSize(),
1577 IsSpdy4() ? kV4FrameData : kV3FrameData,
1578 framer.GetDataFrameMinimumSize());
1579 }
1580
1581 {
1582 const char kDescription[] = "'hello' data frame with more padding, no FIN";
1583 const unsigned char kV3FrameData[] = { // Also applies for V2.
1584 0x00, 0x00, 0x00, 0x01,
1585 0x00, 0x00, 0x00, 0x05,
1586 'h', 'e', 'l', 'l',
1587 'o'
1588 };
1589
1590 const unsigned char kV4FrameData[] = {
1591 0x01, 0x0b, 0x00, 0x18, // Length = 267. PAD_HIGH and PAD_LOW set.
1592 0x00, 0x00, 0x00, 0x01,
1593 0x01, 0x04, // Pad Low and Pad High fields.
1594 'h', 'e', 'l', 'l', // Data
1595 'o',
1596 // Padding of 260 zeros (so both PAD_HIGH and PAD_LOW fields are used).
1597 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1598 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1599 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1600 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1601 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1602 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1603 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1604 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1605 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1606 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1607 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1608 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1609 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1610 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1611 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1612 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1613 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1614 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1615 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1616 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
1617 };
1618 const char bytes[] = "hello";
1619
1620 SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
1621 // 260 zeros and the pad low/high fields make the overall padding to be 262
1622 // bytes.
1623 data_ir.set_padding_len(262);
1624 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1625 if (IsSpdy4()) {
1626 CompareFrame(
1627 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1628 } else {
1629 CompareFrame(
1630 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1631 }
1632
1633 frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
1634 CompareCharArraysWithHexError(
1635 kDescription,
1636 reinterpret_cast<const unsigned char*>(frame->data()),
1637 framer.GetDataFrameMinimumSize(),
1638 IsSpdy4() ? kV4FrameData : kV3FrameData,
1639 framer.GetDataFrameMinimumSize());
1640 }
1641
1642 {
1643 const char kDescription[] = "'hello' data frame with few padding, no FIN";
1644 const unsigned char kV3FrameData[] = { // Also applies for V2.
1645 0x00, 0x00, 0x00, 0x01,
1646 0x00, 0x00, 0x00, 0x05,
1647 'h', 'e', 'l', 'l',
1648 'o'
1649 };
1650
1651 const unsigned char kV4FrameData[] = {
1652 0x00, 0x0d, 0x00, 0x08, // Length = 13. PAD_LOW set.
1653 0x00, 0x00, 0x00, 0x01,
1654 0x07, // Pad Low field.
1655 'h', 'e', 'l', 'l', // Data
1656 'o',
1657 '0', '0', '0', '0', // Padding
1658 '0', '0', '0'
1659 };
1660 const char bytes[] = "hello";
1661
1662 SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
1663 // 7 zeros and the pad low field make the overall padding to be 8 bytes.
1664 data_ir.set_padding_len(8);
1665 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1666 if (IsSpdy4()) {
1667 CompareFrame(
1668 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1669 } else {
1670 CompareFrame(
1671 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1672 }
1673 }
1674
1675 {
1676 const char kDescription[] =
1677 "'hello' data frame with 1 byte padding, no FIN";
1678 const unsigned char kV3FrameData[] = { // Also applies for V2.
1679 0x00, 0x00, 0x00, 0x01,
1680 0x00, 0x00, 0x00, 0x05,
1681 'h', 'e', 'l', 'l',
1682 'o'
1683 };
1684
1685 const unsigned char kV4FrameData[] = {
1686 0x00, 0x06, 0x00, 0x08, // Length = 6. PAD_LOW set.
1687 0x00, 0x00, 0x00, 0x01,
1688 0x00, // Pad Low field.
1689 'h', 'e', 'l', 'l', // Data
1690 'o',
1691 };
1692 const char bytes[] = "hello";
1693
1694 SpdyDataIR data_ir(1, StringPiece(bytes, strlen(bytes)));
1695 // The pad low field itself is used for the 1-byte padding and no padding
1696 // payload is needed.
1697 data_ir.set_padding_len(1);
1698 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1699 if (IsSpdy4()) {
1700 CompareFrame(
1701 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1702 } else {
1703 CompareFrame(
1704 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1705 }
1706
1707 frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
1708 CompareCharArraysWithHexError(
1709 kDescription,
1710 reinterpret_cast<const unsigned char*>(frame->data()),
1711 framer.GetDataFrameMinimumSize(),
1712 IsSpdy4() ? kV4FrameData : kV3FrameData,
1713 framer.GetDataFrameMinimumSize());
1714 }
1715
1716 {
1717 const char kDescription[] = "Data frame with negative data byte, no FIN";
1718 const unsigned char kV3FrameData[] = { // Also applies for V2.
1719 0x00, 0x00, 0x00, 0x01,
1720 0x00, 0x00, 0x00, 0x01,
1721 0xff
1722 };
1723 const unsigned char kV4FrameData[] = {
1724 0x00, 0x01, 0x00, 0x00,
1725 0x00, 0x00, 0x00, 0x01,
1726 0xff
1727 };
1728 SpdyDataIR data_ir(1, StringPiece("\xff", 1));
1729 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1730 if (IsSpdy4()) {
1731 CompareFrame(
1732 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1733 } else {
1734 CompareFrame(
1735 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1736 }
1737 }
1738
1739 {
1740 const char kDescription[] = "'hello' data frame, with FIN";
1741 const unsigned char kV3FrameData[] = { // Also applies for V2.
1742 0x00, 0x00, 0x00, 0x01,
1743 0x01, 0x00, 0x00, 0x05,
1744 'h', 'e', 'l', 'l',
1745 'o'
1746 };
1747 const unsigned char kV4FrameData[] = {
1748 0x00, 0x05, 0x00, 0x01,
1749 0x00, 0x00, 0x00, 0x01,
1750 'h', 'e', 'l', 'l',
1751 'o'
1752 };
1753 SpdyDataIR data_ir(1, StringPiece("hello", 5));
1754 data_ir.set_fin(true);
1755 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1756 if (IsSpdy4()) {
1757 CompareFrame(
1758 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1759 } else {
1760 CompareFrame(
1761 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1762 }
1763 }
1764
1765 {
1766 const char kDescription[] = "Empty data frame";
1767 const unsigned char kV3FrameData[] = { // Also applies for V2.
1768 0x00, 0x00, 0x00, 0x01,
1769 0x00, 0x00, 0x00, 0x00,
1770 };
1771 const unsigned char kV4FrameData[] = {
1772 0x00, 0x00, 0x00, 0x00,
1773 0x00, 0x00, 0x00, 0x01,
1774 };
1775 SpdyDataIR data_ir(1, StringPiece());
1776 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1777 if (IsSpdy4()) {
1778 CompareFrame(
1779 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1780 } else {
1781 CompareFrame(
1782 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1783 }
1784
1785 frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
1786 CompareCharArraysWithHexError(
1787 kDescription,
1788 reinterpret_cast<const unsigned char*>(frame->data()),
1789 framer.GetDataFrameMinimumSize(),
1790 IsSpdy4() ? kV4FrameData : kV3FrameData,
1791 framer.GetDataFrameMinimumSize());
1792 }
1793
1794 {
1795 const char kDescription[] = "Data frame with max stream ID";
1796 const unsigned char kV3FrameData[] = { // Also applies for V2.
1797 0x7f, 0xff, 0xff, 0xff,
1798 0x01, 0x00, 0x00, 0x05,
1799 'h', 'e', 'l', 'l',
1800 'o'
1801 };
1802 const unsigned char kV4FrameData[] = {
1803 0x00, 0x05, 0x00, 0x01,
1804 0x7f, 0xff, 0xff, 0xff,
1805 'h', 'e', 'l', 'l',
1806 'o'
1807 };
1808 SpdyDataIR data_ir(0x7fffffff, "hello");
1809 data_ir.set_fin(true);
1810 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1811 if (IsSpdy4()) {
1812 CompareFrame(
1813 kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1814 } else {
1815 CompareFrame(
1816 kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1817 }
1818 }
1819
1820 if (!IsSpdy4()) {
1821 // This test does not apply to SPDY 4 because the max frame size is smaller
1822 // than 4MB.
1823 const char kDescription[] = "Large data frame";
1824 const int kDataSize = 4 * 1024 * 1024; // 4 MB
1825 const string kData(kDataSize, 'A');
1826 const unsigned char kFrameHeader[] = {
1827 0x00, 0x00, 0x00, 0x01,
1828 0x01, 0x40, 0x00, 0x00,
1829 };
1830
1831 const int kFrameSize = arraysize(kFrameHeader) + kDataSize;
1832 scoped_ptr<unsigned char[]> expected_frame_data(
1833 new unsigned char[kFrameSize]);
1834 memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
1835 memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
1836
1837 SpdyDataIR data_ir(1, StringPiece(kData.data(), kData.size()));
1838 data_ir.set_fin(true);
1839 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
1840 CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
1841 }
1842 }
1843
1844 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
1845 SpdyFramer framer(spdy_version_);
1846 framer.set_enable_compression(false);
1847
1848 {
1849 const char kDescription[] = "SYN_STREAM frame, lowest pri, no FIN";
1850
1851 const unsigned char kPri = IsSpdy2() ? 0xC0 : 0xE0;
1852 const unsigned char kV2FrameData[] = {
1853 0x80, spdy_version_ch_, 0x00, 0x01,
1854 0x00, 0x00, 0x00, 0x20,
1855 0x00, 0x00, 0x00, 0x01,
1856 0x00, 0x00, 0x00, 0x00,
1857 kPri, 0x00, 0x00, 0x02,
1858 0x00, 0x03, 'b', 'a',
1859 'r', 0x00, 0x03, 'f',
1860 'o', 'o', 0x00, 0x03,
1861 'f', 'o', 'o', 0x00,
1862 0x03, 'b', 'a', 'r'
1863 };
1864 const unsigned char kV3FrameData[] = {
1865 0x80, spdy_version_ch_, 0x00, 0x01,
1866 0x00, 0x00, 0x00, 0x2a,
1867 0x00, 0x00, 0x00, 0x01,
1868 0x00, 0x00, 0x00, 0x00,
1869 kPri, 0x00, 0x00, 0x00,
1870 0x00, 0x02, 0x00, 0x00,
1871 0x00, 0x03, 'b', 'a',
1872 'r', 0x00, 0x00, 0x00,
1873 0x03, 'f', 'o', 'o',
1874 0x00, 0x00, 0x00, 0x03,
1875 'f', 'o', 'o', 0x00,
1876 0x00, 0x00, 0x03, 'b',
1877 'a', 'r'
1878 };
1879 const unsigned char kV4FrameData[] = {
1880 0x00, 0x17, 0x01, 0x24, // HEADERS: PRIORITY | END_HEADERS
1881 0x00, 0x00, 0x00, 0x01, // Stream 1
1882 0x00, 0x00, 0x00, 0x00, // Non-exclusive dependency 0. Weight 0.
1883 0x00, 0x00, 0x03, 0x62,
1884 0x61, 0x72, 0x03, 0x66,
1885 0x6f, 0x6f, 0x00, 0x03,
1886 0x66, 0x6f, 0x6f, 0x03,
1887 0x62, 0x61, 0x72,
1888 };
1889 SpdySynStreamIR syn_stream(1);
1890 syn_stream.set_priority(framer.GetLowestPriority());
1891 syn_stream.SetHeader("bar", "foo");
1892 syn_stream.SetHeader("foo", "bar");
1893 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
1894 if (IsSpdy2()) {
1895 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
1896 } else if (IsSpdy3()) {
1897 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1898 } else {
1899 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1900 }
1901 }
1902
1903 {
1904 const char kDescription[] =
1905 "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
1906 "max stream ID";
1907
1908 const unsigned char kV2FrameData[] = {
1909 0x80, spdy_version_ch_, 0x00, 0x01,
1910 0x01, 0x00, 0x00, 0x1D,
1911 0x7f, 0xff, 0xff, 0xff,
1912 0x7f, 0xff, 0xff, 0xff,
1913 0x00, 0x00, 0x00, 0x02,
1914 0x00, 0x00, 0x00, 0x03,
1915 'f', 'o', 'o', 0x00,
1916 0x03, 'f', 'o', 'o',
1917 0x00, 0x03, 'b', 'a',
1918 'r'
1919 };
1920 const unsigned char kV3FrameData[] = {
1921 0x80, spdy_version_ch_, 0x00, 0x01,
1922 0x01, 0x00, 0x00, 0x27,
1923 0x7f, 0xff, 0xff, 0xff,
1924 0x7f, 0xff, 0xff, 0xff,
1925 0x00, 0x00, 0x00, 0x00,
1926 0x00, 0x02, 0x00, 0x00,
1927 0x00, 0x00, 0x00, 0x00,
1928 0x00, 0x03, 'f', 'o',
1929 'o', 0x00, 0x00, 0x00,
1930 0x03, 'f', 'o', 'o',
1931 0x00, 0x00, 0x00, 0x03,
1932 'b', 'a', 'r'
1933 };
1934 const unsigned char kV4FrameData[] = {
1935 0x00, 0x14, 0x01, 0x25, // HEADERS: PRIORITY | FIN | END_HEADERS
1936 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
1937 0x00, 0x00, 0x00, 0x00, // Non-exclusive dependency 0. Weight 255.
1938 0xff, 0x00, 0x00, 0x03,
1939 0x66, 0x6f, 0x6f, 0x00,
1940 0x03, 0x66, 0x6f, 0x6f,
1941 0x03, 0x62, 0x61, 0x72,
1942 };
1943 SpdySynStreamIR syn_stream(0x7fffffff);
1944 syn_stream.set_associated_to_stream_id(0x7fffffff);
1945 syn_stream.set_priority(framer.GetHighestPriority());
1946 syn_stream.set_fin(true);
1947 syn_stream.SetHeader("", "foo");
1948 syn_stream.SetHeader("foo", "bar");
1949 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
1950 if (IsSpdy2()) {
1951 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
1952 } else if (IsSpdy3()) {
1953 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
1954 } else {
1955 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
1956 }
1957 }
1958
1959 {
1960 const char kDescription[] =
1961 "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
1962 "max stream ID";
1963
1964 const unsigned char kPri = IsSpdy2() ? 0x40 : 0x20;
1965 const unsigned char kV2FrameData[] = {
1966 0x80, spdy_version_ch_, 0x00, 0x01,
1967 0x01, 0x00, 0x00, 0x1D,
1968 0x7f, 0xff, 0xff, 0xff,
1969 0x7f, 0xff, 0xff, 0xff,
1970 kPri, 0x00, 0x00, 0x02,
1971 0x00, 0x03, 'b', 'a',
1972 'r', 0x00, 0x03, 'f',
1973 'o', 'o', 0x00, 0x03,
1974 'f', 'o', 'o', 0x00,
1975 0x00
1976 };
1977 const unsigned char kV3FrameData[] = {
1978 0x80, spdy_version_ch_, 0x00, 0x01,
1979 0x01, 0x00, 0x00, 0x27,
1980 0x7f, 0xff, 0xff, 0xff,
1981 0x7f, 0xff, 0xff, 0xff,
1982 kPri, 0x00, 0x00, 0x00,
1983 0x00, 0x02, 0x00, 0x00,
1984 0x00, 0x03, 'b', 'a',
1985 'r', 0x00, 0x00, 0x00,
1986 0x03, 'f', 'o', 'o',
1987 0x00, 0x00, 0x00, 0x03,
1988 'f', 'o', 'o', 0x00,
1989 0x00, 0x00, 0x00
1990 };
1991 const unsigned char kV4FrameData[] = {
1992 0x00, 0x14, 0x01, 0x25, // HEADERS: PRIORITY | FIN | END_HEADERS
1993 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
1994 0x00, 0x00, 0x00, 0x00, // Non-exclusive dependency 0. Weight 219.
1995 0xdb, 0x00, 0x03, 0x62,
1996 0x61, 0x72, 0x03, 0x66,
1997 0x6f, 0x6f, 0x00, 0x03,
1998 0x66, 0x6f, 0x6f, 0x00,
1999 };
2000 SpdySynStreamIR syn_stream(0x7fffffff);
2001 syn_stream.set_associated_to_stream_id(0x7fffffff);
2002 syn_stream.set_priority(1);
2003 syn_stream.set_fin(true);
2004 syn_stream.SetHeader("bar", "foo");
2005 syn_stream.SetHeader("foo", "");
2006 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
2007 if (IsSpdy2()) {
2008 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2009 } else if (IsSpdy3()) {
2010 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2011 } else {
2012 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2013 }
2014 }
2015 }
2016
2017 // TODO(phajdan.jr): Clean up after we no longer need
2018 // to workaround http://crbug.com/139744.
2019 #if !defined(USE_SYSTEM_ZLIB)
2020 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
2021 SpdyFramer framer(spdy_version_);
2022 framer.set_enable_compression(true);
2023
2024 {
2025 const char kDescription[] =
2026 "SYN_STREAM frame, low pri, no FIN";
2027
2028 const SpdyPriority priority = IsSpdy2() ? 2 : 4;
2029 const unsigned char kV2FrameData[] = {
2030 0x80, spdy_version_ch_, 0x00, 0x01,
2031 0x00, 0x00, 0x00, 0x36,
2032 0x00, 0x00, 0x00, 0x01,
2033 0x00, 0x00, 0x00, 0x00,
2034 0x80, 0x00, 0x38, 0xea,
2035 0xdf, 0xa2, 0x51, 0xb2,
2036 0x62, 0x60, 0x62, 0x60,
2037 0x4e, 0x4a, 0x2c, 0x62,
2038 0x60, 0x06, 0x08, 0xa0,
2039 0xb4, 0xfc, 0x7c, 0x80,
2040 0x00, 0x62, 0x60, 0x4e,
2041 0xcb, 0xcf, 0x67, 0x60,
2042 0x06, 0x08, 0xa0, 0xa4,
2043 0xc4, 0x22, 0x80, 0x00,
2044 0x02, 0x00, 0x00, 0x00,
2045 0xff, 0xff,
2046 };
2047 const unsigned char kV3FrameData[] = {
2048 0x80, spdy_version_ch_, 0x00, 0x01,
2049 0x00, 0x00, 0x00, 0x37,
2050 0x00, 0x00, 0x00, 0x01,
2051 0x00, 0x00, 0x00, 0x00,
2052 0x80, 0x00, 0x38, 0xEA,
2053 0xE3, 0xC6, 0xA7, 0xC2,
2054 0x02, 0xE5, 0x0E, 0x50,
2055 0xC2, 0x4B, 0x4A, 0x04,
2056 0xE5, 0x0B, 0x66, 0x80,
2057 0x00, 0x4A, 0xCB, 0xCF,
2058 0x07, 0x08, 0x20, 0x10,
2059 0x95, 0x96, 0x9F, 0x0F,
2060 0xA2, 0x00, 0x02, 0x28,
2061 0x29, 0xB1, 0x08, 0x20,
2062 0x80, 0x00, 0x00, 0x00,
2063 0x00, 0xFF, 0xFF,
2064 };
2065 SpdySynStreamIR syn_stream(1);
2066 syn_stream.set_priority(priority);
2067 syn_stream.SetHeader("bar", "foo");
2068 syn_stream.SetHeader("foo", "bar");
2069 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
2070 if (IsSpdy2()) {
2071 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2072 } else if (IsSpdy3()) {
2073 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2074 } else {
2075 // Deflate compression doesn't apply to HPACK.
2076 }
2077 }
2078 }
2079 #endif // !defined(USE_SYSTEM_ZLIB)
2080
2081 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
2082 SpdyFramer framer(spdy_version_);
2083 framer.set_enable_compression(false);
2084
2085 {
2086 const char kDescription[] = "SYN_REPLY frame, no FIN";
2087
2088 const unsigned char kV2FrameData[] = {
2089 0x80, spdy_version_ch_, 0x00, 0x02,
2090 0x00, 0x00, 0x00, 0x1C,
2091 0x00, 0x00, 0x00, 0x01,
2092 0x00, 0x00, 0x00, 0x02,
2093 0x00, 0x03, 'b', 'a',
2094 'r', 0x00, 0x03, 'f',
2095 'o', 'o', 0x00, 0x03,
2096 'f', 'o', 'o', 0x00,
2097 0x03, 'b', 'a', 'r'
2098 };
2099 const unsigned char kV3FrameData[] = {
2100 0x80, spdy_version_ch_, 0x00, 0x02,
2101 0x00, 0x00, 0x00, 0x24,
2102 0x00, 0x00, 0x00, 0x01,
2103 0x00, 0x00, 0x00, 0x02,
2104 0x00, 0x00, 0x00, 0x03,
2105 'b', 'a', 'r', 0x00,
2106 0x00, 0x00, 0x03, 'f',
2107 'o', 'o', 0x00, 0x00,
2108 0x00, 0x03, 'f', 'o',
2109 'o', 0x00, 0x00, 0x00,
2110 0x03, 'b', 'a', 'r'
2111 };
2112 const unsigned char kV4FrameData[] = {
2113 0x00, 0x12, 0x01, 0x04, // HEADER: END_HEADERS
2114 0x00, 0x00, 0x00, 0x01, // Stream 1
2115 0x00, 0x03, 0x62, 0x61, // @.ba
2116 0x72, 0x03, 0x66, 0x6f, // r.fo
2117 0x6f, 0x00, 0x03, 0x66, // o@.f
2118 0x6f, 0x6f, 0x03, 0x62, // oo.b
2119 0x61, 0x72, // ar
2120 };
2121 SpdySynReplyIR syn_reply(1);
2122 syn_reply.SetHeader("bar", "foo");
2123 syn_reply.SetHeader("foo", "bar");
2124 scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
2125 if (IsSpdy2()) {
2126 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2127 } else if (IsSpdy3()) {
2128 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2129 } else {
2130 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2131 }
2132 }
2133
2134 {
2135 const char kDescription[] =
2136 "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
2137
2138 const unsigned char kV2FrameData[] = {
2139 0x80, spdy_version_ch_, 0x00, 0x02,
2140 0x01, 0x00, 0x00, 0x19,
2141 0x7f, 0xff, 0xff, 0xff,
2142 0x00, 0x00, 0x00, 0x02,
2143 0x00, 0x00, 0x00, 0x03,
2144 'f', 'o', 'o', 0x00,
2145 0x03, 'f', 'o', 'o',
2146 0x00, 0x03, 'b', 'a',
2147 'r'
2148 };
2149 const unsigned char kV3FrameData[] = {
2150 0x80, spdy_version_ch_, 0x00, 0x02,
2151 0x01, 0x00, 0x00, 0x21,
2152 0x7f, 0xff, 0xff, 0xff,
2153 0x00, 0x00, 0x00, 0x02,
2154 0x00, 0x00, 0x00, 0x00,
2155 0x00, 0x00, 0x00, 0x03,
2156 'f', 'o', 'o', 0x00,
2157 0x00, 0x00, 0x03, 'f',
2158 'o', 'o', 0x00, 0x00,
2159 0x00, 0x03, 'b', 'a',
2160 'r'
2161 };
2162 const unsigned char kV4FrameData[] = {
2163 0x00, 0x0f, 0x01, 0x05, // HEADER: FIN | END_HEADERS
2164 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
2165 0x00, 0x00, 0x03, 0x66, // @..f
2166 0x6f, 0x6f, 0x00, 0x03, // oo@.
2167 0x66, 0x6f, 0x6f, 0x03, // foo.
2168 0x62, 0x61, 0x72, // bar
2169 };
2170 SpdySynReplyIR syn_reply(0x7fffffff);
2171 syn_reply.set_fin(true);
2172 syn_reply.SetHeader("", "foo");
2173 syn_reply.SetHeader("foo", "bar");
2174 scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
2175 if (IsSpdy2()) {
2176 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2177 } else if (IsSpdy3()) {
2178 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2179 } else {
2180 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2181 }
2182 }
2183
2184 {
2185 const char kDescription[] =
2186 "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
2187
2188 const unsigned char kV2FrameData[] = {
2189 0x80, spdy_version_ch_, 0x00, 0x02,
2190 0x01, 0x00, 0x00, 0x19,
2191 0x7f, 0xff, 0xff, 0xff,
2192 0x00, 0x00, 0x00, 0x02,
2193 0x00, 0x03, 'b', 'a',
2194 'r', 0x00, 0x03, 'f',
2195 'o', 'o', 0x00, 0x03,
2196 'f', 'o', 'o', 0x00,
2197 0x00
2198 };
2199 const unsigned char kV3FrameData[] = {
2200 0x80, spdy_version_ch_, 0x00, 0x02,
2201 0x01, 0x00, 0x00, 0x21,
2202 0x7f, 0xff, 0xff, 0xff,
2203 0x00, 0x00, 0x00, 0x02,
2204 0x00, 0x00, 0x00, 0x03,
2205 'b', 'a', 'r', 0x00,
2206 0x00, 0x00, 0x03, 'f',
2207 'o', 'o', 0x00, 0x00,
2208 0x00, 0x03, 'f', 'o',
2209 'o', 0x00, 0x00, 0x00,
2210 0x00
2211 };
2212 const unsigned char kV4FrameData[] = {
2213 0x00, 0x0f, 0x01, 0x05, // HEADER: FIN | END_HEADERS
2214 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
2215 0x00, 0x03, 0x62, 0x61, // @.ba
2216 0x72, 0x03, 0x66, 0x6f, // r.fo
2217 0x6f, 0x00, 0x03, 0x66, // o@.f
2218 0x6f, 0x6f, 0x00, // oo.
2219 };
2220 SpdySynReplyIR syn_reply(0x7fffffff);
2221 syn_reply.set_fin(true);
2222 syn_reply.SetHeader("bar", "foo");
2223 syn_reply.SetHeader("foo", "");
2224 scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
2225 if (IsSpdy2()) {
2226 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2227 } else if (IsSpdy3()) {
2228 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2229 } else {
2230 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2231 }
2232 }
2233 }
2234
2235 // TODO(phajdan.jr): Clean up after we no longer need
2236 // to workaround http://crbug.com/139744.
2237 #if !defined(USE_SYSTEM_ZLIB)
2238 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
2239 SpdyFramer framer(spdy_version_);
2240 framer.set_enable_compression(true);
2241
2242 {
2243 const char kDescription[] = "SYN_REPLY frame, no FIN";
2244
2245 const unsigned char kV2FrameData[] = {
2246 0x80, spdy_version_ch_, 0x00, 0x02,
2247 0x00, 0x00, 0x00, 0x32,
2248 0x00, 0x00, 0x00, 0x01,
2249 0x00, 0x00, 0x38, 0xea,
2250 0xdf, 0xa2, 0x51, 0xb2,
2251 0x62, 0x60, 0x62, 0x60,
2252 0x4e, 0x4a, 0x2c, 0x62,
2253 0x60, 0x06, 0x08, 0xa0,
2254 0xb4, 0xfc, 0x7c, 0x80,
2255 0x00, 0x62, 0x60, 0x4e,
2256 0xcb, 0xcf, 0x67, 0x60,
2257 0x06, 0x08, 0xa0, 0xa4,
2258 0xc4, 0x22, 0x80, 0x00,
2259 0x02, 0x00, 0x00, 0x00,
2260 0xff, 0xff,
2261 };
2262 const unsigned char kV3FrameData[] = {
2263 0x80, spdy_version_ch_, 0x00, 0x02,
2264 0x00, 0x00, 0x00, 0x31,
2265 0x00, 0x00, 0x00, 0x01,
2266 0x38, 0xea, 0xe3, 0xc6,
2267 0xa7, 0xc2, 0x02, 0xe5,
2268 0x0e, 0x50, 0xc2, 0x4b,
2269 0x4a, 0x04, 0xe5, 0x0b,
2270 0x66, 0x80, 0x00, 0x4a,
2271 0xcb, 0xcf, 0x07, 0x08,
2272 0x20, 0x10, 0x95, 0x96,
2273 0x9f, 0x0f, 0xa2, 0x00,
2274 0x02, 0x28, 0x29, 0xb1,
2275 0x08, 0x20, 0x80, 0x00,
2276 0x00, 0x00, 0x00, 0xff,
2277 0xff,
2278 };
2279 SpdySynReplyIR syn_reply(1);
2280 syn_reply.SetHeader("bar", "foo");
2281 syn_reply.SetHeader("foo", "bar");
2282 scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
2283 if (IsSpdy2()) {
2284 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2285 } else if (IsSpdy3()) {
2286 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2287 } else {
2288 // Deflate compression doesn't apply to HPACK.
2289 }
2290 }
2291 }
2292 #endif // !defined(USE_SYSTEM_ZLIB)
2293
2294 TEST_P(SpdyFramerTest, CreateRstStream) {
2295 SpdyFramer framer(spdy_version_);
2296
2297 {
2298 const char kDescription[] = "RST_STREAM frame";
2299 const unsigned char kV3FrameData[] = { // Also applies for V2.
2300 0x80, spdy_version_ch_, 0x00, 0x03,
2301 0x00, 0x00, 0x00, 0x08,
2302 0x00, 0x00, 0x00, 0x01,
2303 0x00, 0x00, 0x00, 0x01,
2304 };
2305 const unsigned char kV4FrameData[] = {
2306 0x00, 0x07, 0x03, 0x00,
2307 0x00, 0x00, 0x00, 0x01,
2308 0x00, 0x00, 0x00, 0x01,
2309 0x52, 0x53, 0x54
2310 };
2311 SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR, "RST");
2312 scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
2313 if (IsSpdy4()) {
2314 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2315 } else {
2316 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2317 }
2318 }
2319
2320 {
2321 const char kDescription[] = "RST_STREAM frame with max stream ID";
2322 const unsigned char kV3FrameData[] = { // Also applies for V2.
2323 0x80, spdy_version_ch_, 0x00, 0x03,
2324 0x00, 0x00, 0x00, 0x08,
2325 0x7f, 0xff, 0xff, 0xff,
2326 0x00, 0x00, 0x00, 0x01,
2327 };
2328 const unsigned char kV4FrameData[] = {
2329 0x00, 0x04, 0x03, 0x00,
2330 0x7f, 0xff, 0xff, 0xff,
2331 0x00, 0x00, 0x00, 0x01,
2332 };
2333 SpdyRstStreamIR rst_stream(0x7FFFFFFF,
2334 RST_STREAM_PROTOCOL_ERROR,
2335 "");
2336 scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
2337 if (IsSpdy4()) {
2338 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2339 } else {
2340 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2341 }
2342 }
2343
2344 {
2345 const char kDescription[] = "RST_STREAM frame with max status code";
2346 const unsigned char kV3FrameData[] = { // Also applies for V2.
2347 0x80, spdy_version_ch_, 0x00, 0x03,
2348 0x00, 0x00, 0x00, 0x08,
2349 0x7f, 0xff, 0xff, 0xff,
2350 0x00, 0x00, 0x00, 0x06,
2351 };
2352 const unsigned char kV4FrameData[] = {
2353 0x00, 0x04, 0x03, 0x00,
2354 0x7f, 0xff, 0xff, 0xff,
2355 0x00, 0x00, 0x00, 0x06,
2356 };
2357 SpdyRstStreamIR rst_stream(0x7FFFFFFF,
2358 RST_STREAM_INTERNAL_ERROR,
2359 "");
2360 scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
2361 if (IsSpdy4()) {
2362 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2363 } else {
2364 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2365 }
2366 }
2367 }
2368
2369 TEST_P(SpdyFramerTest, CreateSettings) {
2370 SpdyFramer framer(spdy_version_);
2371
2372 {
2373 const char kDescription[] = "Network byte order SETTINGS frame";
2374
2375 const unsigned char kV2FrameData[] = {
2376 0x80, spdy_version_ch_, 0x00, 0x04,
2377 0x00, 0x00, 0x00, 0x0c,
2378 0x00, 0x00, 0x00, 0x01,
2379 0x07, 0x00, 0x00, 0x01,
2380 0x0a, 0x0b, 0x0c, 0x0d,
2381 };
2382 const unsigned char kV3FrameData[] = {
2383 0x80, spdy_version_ch_, 0x00, 0x04,
2384 0x00, 0x00, 0x00, 0x0c,
2385 0x00, 0x00, 0x00, 0x01,
2386 0x01, 0x00, 0x00, 0x07,
2387 0x0a, 0x0b, 0x0c, 0x0d,
2388 };
2389 const unsigned char kV4FrameData[] = {
2390 0x00, 0x05, 0x04, 0x00,
2391 0x00, 0x00, 0x00, 0x00,
2392 0x04, 0x0a, 0x0b, 0x0c,
2393 0x0d,
2394 };
2395
2396 uint32 kValue = 0x0a0b0c0d;
2397 SpdySettingsIR settings_ir;
2398
2399 SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
2400 SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
2401 SettingsMap settings;
2402 settings[kId] = SettingsFlagsAndValue(kFlags, kValue);
2403 EXPECT_EQ(kFlags, settings[kId].first);
2404 EXPECT_EQ(kValue, settings[kId].second);
2405 settings_ir.AddSetting(kId,
2406 kFlags & SETTINGS_FLAG_PLEASE_PERSIST,
2407 kFlags & SETTINGS_FLAG_PERSISTED,
2408 kValue);
2409
2410 scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
2411 if (IsSpdy2()) {
2412 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2413 } else if (IsSpdy3()) {
2414 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2415 } else {
2416 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2417 }
2418 }
2419
2420 {
2421 const char kDescription[] = "Basic SETTINGS frame";
2422
2423 const unsigned char kV2FrameData[] = {
2424 0x80, spdy_version_ch_, 0x00, 0x04,
2425 0x00, 0x00, 0x00, 0x24,
2426 0x00, 0x00, 0x00, 0x04,
2427 0x01, 0x00, 0x00, 0x00, // 1st Setting
2428 0x00, 0x00, 0x00, 0x05,
2429 0x02, 0x00, 0x00, 0x00, // 2nd Setting
2430 0x00, 0x00, 0x00, 0x06,
2431 0x03, 0x00, 0x00, 0x00, // 3rd Setting
2432 0x00, 0x00, 0x00, 0x07,
2433 0x04, 0x00, 0x00, 0x00, // 4th Setting
2434 0x00, 0x00, 0x00, 0x08,
2435 };
2436 const unsigned char kV3FrameData[] = {
2437 0x80, spdy_version_ch_, 0x00, 0x04,
2438 0x00, 0x00, 0x00, 0x24,
2439 0x00, 0x00, 0x00, 0x04,
2440 0x00, 0x00, 0x00, 0x01, // 1st Setting
2441 0x00, 0x00, 0x00, 0x05,
2442 0x00, 0x00, 0x00, 0x02, // 2nd Setting
2443 0x00, 0x00, 0x00, 0x06,
2444 0x00, 0x00, 0x00, 0x03, // 3rd Setting
2445 0x00, 0x00, 0x00, 0x07,
2446 0x00, 0x00, 0x00, 0x04, // 4th Setting
2447 0x00, 0x00, 0x00, 0x08,
2448 };
2449 // These end up seemingly out of order because of the way that our internal
2450 // ordering for settings_ir works. HTTP2 has no requirement on ordering on
2451 // the wire.
2452 const unsigned char kV4FrameData[] = {
2453 0x00, 0x14, 0x04, 0x00,
2454 0x00, 0x00, 0x00, 0x00,
2455 0x03, // 3rd Setting
2456 0x00, 0x00, 0x00, 0x07,
2457 0x04, // 4th Setting
2458 0x00, 0x00, 0x00, 0x08,
2459 0x01, // 1st Setting
2460 0x00, 0x00, 0x00, 0x05,
2461 0x02, // 2nd Setting
2462 0x00, 0x00, 0x00, 0x06,
2463 };
2464
2465 SpdySettingsIR settings_ir;
2466 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
2467 false, // persist
2468 false, // persisted
2469 5);
2470 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
2471 false, // persist
2472 false, // persisted
2473 6);
2474 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
2475 false, // persist
2476 false, // persisted
2477 7);
2478 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 4),
2479 false, // persist
2480 false, // persisted
2481 8);
2482 scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
2483
2484 if (IsSpdy2()) {
2485 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2486 } else if (IsSpdy3()) {
2487 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2488 } else {
2489 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2490 }
2491 }
2492
2493 {
2494 const char kDescription[] = "Empty SETTINGS frame";
2495
2496 const unsigned char kV3FrameData[] = { // Also applies for V2.
2497 0x80, spdy_version_ch_, 0x00, 0x04,
2498 0x00, 0x00, 0x00, 0x04,
2499 0x00, 0x00, 0x00, 0x00,
2500 };
2501 const unsigned char kV4FrameData[] = {
2502 0x00, 0x00, 0x04, 0x00,
2503 0x00, 0x00, 0x00, 0x00,
2504 };
2505 SpdySettingsIR settings_ir;
2506 scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
2507 if (IsSpdy4()) {
2508 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2509 } else {
2510 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2511 }
2512 }
2513 }
2514
2515 TEST_P(SpdyFramerTest, CreatePingFrame) {
2516 SpdyFramer framer(spdy_version_);
2517
2518 {
2519 const char kDescription[] = "PING frame";
2520 const unsigned char kV3FrameData[] = { // Also applies for V2.
2521 0x80, spdy_version_ch_, 0x00, 0x06,
2522 0x00, 0x00, 0x00, 0x04,
2523 0x12, 0x34, 0x56, 0x78,
2524 };
2525 const unsigned char kV4FrameData[] = {
2526 0x00, 0x08, 0x06, 0x00,
2527 0x00, 0x00, 0x00, 0x00,
2528 0x12, 0x34, 0x56, 0x78,
2529 0x9a, 0xbc, 0xde, 0xff,
2530 };
2531 const unsigned char kV4FrameDataWithAck[] = {
2532 0x00, 0x08, 0x06, 0x01,
2533 0x00, 0x00, 0x00, 0x00,
2534 0x12, 0x34, 0x56, 0x78,
2535 0x9a, 0xbc, 0xde, 0xff,
2536 };
2537 scoped_ptr<SpdyFrame> frame;
2538 if (IsSpdy4()) {
2539 const SpdyPingId kPingId = 0x123456789abcdeffULL;
2540 SpdyPingIR ping_ir(kPingId);
2541 // Tests SpdyPingIR when the ping is not an ack.
2542 ASSERT_FALSE(ping_ir.is_ack());
2543 frame.reset(framer.SerializePing(ping_ir));
2544 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2545
2546 // Tests SpdyPingIR when the ping is an ack.
2547 ping_ir.set_is_ack(true);
2548 frame.reset(framer.SerializePing(ping_ir));
2549 CompareFrame(kDescription, *frame,
2550 kV4FrameDataWithAck, arraysize(kV4FrameDataWithAck));
2551
2552 } else {
2553 frame.reset(framer.SerializePing(SpdyPingIR(0x12345678ull)));
2554 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2555 }
2556 }
2557 }
2558
2559 TEST_P(SpdyFramerTest, CreateGoAway) {
2560 SpdyFramer framer(spdy_version_);
2561
2562 {
2563 const char kDescription[] = "GOAWAY frame";
2564 const unsigned char kV2FrameData[] = {
2565 0x80, spdy_version_ch_, 0x00, 0x07,
2566 0x00, 0x00, 0x00, 0x04,
2567 0x00, 0x00, 0x00, 0x00, // Stream Id
2568 };
2569 const unsigned char kV3FrameData[] = {
2570 0x80, spdy_version_ch_, 0x00, 0x07,
2571 0x00, 0x00, 0x00, 0x08,
2572 0x00, 0x00, 0x00, 0x00, // Stream Id
2573 0x00, 0x00, 0x00, 0x00, // Status
2574 };
2575 const unsigned char kV4FrameData[] = {
2576 0x00, 0x0a, 0x07, 0x00,
2577 0x00, 0x00, 0x00, 0x00,
2578 0x00, 0x00, 0x00, 0x00, // Stream id
2579 0x00, 0x00, 0x00, 0x00, // Status
2580 0x47, 0x41, // Opaque Description
2581 };
2582 SpdyGoAwayIR goaway_ir(0, GOAWAY_OK, "GA");
2583 scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
2584 if (IsSpdy2()) {
2585 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2586 } else if (IsSpdy3()) {
2587 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2588 } else {
2589 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2590 }
2591 }
2592
2593 {
2594 const char kDescription[] = "GOAWAY frame with max stream ID, status";
2595 const unsigned char kV2FrameData[] = {
2596 0x80, spdy_version_ch_, 0x00, 0x07,
2597 0x00, 0x00, 0x00, 0x04,
2598 0x7f, 0xff, 0xff, 0xff, // Stream Id
2599 };
2600 const unsigned char kV3FrameData[] = {
2601 0x80, spdy_version_ch_, 0x00, 0x07,
2602 0x00, 0x00, 0x00, 0x08,
2603 0x7f, 0xff, 0xff, 0xff, // Stream Id
2604 0x00, 0x00, 0x00, 0x02, // Status
2605 };
2606 const unsigned char kV4FrameData[] = {
2607 0x00, 0x0a, 0x07, 0x00,
2608 0x00, 0x00, 0x00, 0x00,
2609 0x7f, 0xff, 0xff, 0xff, // Stream Id
2610 0x00, 0x00, 0x00, 0x02, // Status
2611 0x47, 0x41, // Opaque Description
2612 };
2613 SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
2614 scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
2615 if (IsSpdy2()) {
2616 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2617 } else if (IsSpdy3()) {
2618 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2619 } else {
2620 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2621 }
2622 }
2623 }
2624
2625 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
2626 SpdyFramer framer(spdy_version_);
2627 framer.set_enable_compression(false);
2628
2629 {
2630 const char kDescription[] = "HEADERS frame, no FIN";
2631
2632 const unsigned char kV2FrameData[] = {
2633 0x80, spdy_version_ch_, 0x00, 0x08,
2634 0x00, 0x00, 0x00, 0x1C,
2635 0x00, 0x00, 0x00, 0x01,
2636 0x00, 0x00, 0x00, 0x02,
2637 0x00, 0x03, 'b', 'a',
2638 'r', 0x00, 0x03, 'f',
2639 'o', 'o', 0x00, 0x03,
2640 'f', 'o', 'o', 0x00,
2641 0x03, 'b', 'a', 'r'
2642 };
2643 const unsigned char kV3FrameData[] = {
2644 0x80, spdy_version_ch_, 0x00, 0x08,
2645 0x00, 0x00, 0x00, 0x24,
2646 0x00, 0x00, 0x00, 0x01,
2647 0x00, 0x00, 0x00, 0x02,
2648 0x00, 0x00, 0x00, 0x03,
2649 'b', 'a', 'r', 0x00,
2650 0x00, 0x00, 0x03, 'f',
2651 'o', 'o', 0x00, 0x00,
2652 0x00, 0x03, 'f', 'o',
2653 'o', 0x00, 0x00, 0x00,
2654 0x03, 'b', 'a', 'r'
2655 };
2656 const unsigned char kV4FrameData[] = {
2657 0x00, 0x12, 0x01, 0x04, // Headers: END_HEADERS
2658 0x00, 0x00, 0x00, 0x01, // Stream 1
2659 0x00, 0x03, 0x62, 0x61, // @.ba
2660 0x72, 0x03, 0x66, 0x6f, // r.fo
2661 0x6f, 0x00, 0x03, 0x66, // o@.f
2662 0x6f, 0x6f, 0x03, 0x62, // oo.b
2663 0x61, 0x72, // ar
2664 };
2665 SpdyHeadersIR headers_ir(1);
2666 headers_ir.SetHeader("bar", "foo");
2667 headers_ir.SetHeader("foo", "bar");
2668 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
2669 if (IsSpdy2()) {
2670 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2671 } else if (IsSpdy3()) {
2672 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2673 } else {
2674 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2675 }
2676 }
2677
2678 {
2679 const char kDescription[] =
2680 "HEADERS frame with a 0-length header name, FIN, max stream ID";
2681
2682 const unsigned char kV2FrameData[] = {
2683 0x80, spdy_version_ch_, 0x00, 0x08,
2684 0x01, 0x00, 0x00, 0x19,
2685 0x7f, 0xff, 0xff, 0xff,
2686 0x00, 0x00, 0x00, 0x02,
2687 0x00, 0x00, 0x00, 0x03,
2688 'f', 'o', 'o', 0x00,
2689 0x03, 'f', 'o', 'o',
2690 0x00, 0x03, 'b', 'a',
2691 'r'
2692 };
2693 const unsigned char kV3FrameData[] = {
2694 0x80, spdy_version_ch_, 0x00, 0x08,
2695 0x01, 0x00, 0x00, 0x21,
2696 0x7f, 0xff, 0xff, 0xff,
2697 0x00, 0x00, 0x00, 0x02,
2698 0x00, 0x00, 0x00, 0x00,
2699 0x00, 0x00, 0x00, 0x03,
2700 'f', 'o', 'o', 0x00,
2701 0x00, 0x00, 0x03, 'f',
2702 'o', 'o', 0x00, 0x00,
2703 0x00, 0x03, 'b', 'a',
2704 'r'
2705 };
2706 const unsigned char kV4FrameData[] = {
2707 0x00, 0x0f, 0x01, 0x05, // HEADER: FIN | END_HEADERS
2708 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
2709 0x00, 0x00, 0x03, 0x66, // @..f
2710 0x6f, 0x6f, 0x00, 0x03, // oo@.
2711 0x66, 0x6f, 0x6f, 0x03, // foo.
2712 0x62, 0x61, 0x72, // bar
2713 };
2714 SpdyHeadersIR headers_ir(0x7fffffff);
2715 headers_ir.set_fin(true);
2716 headers_ir.SetHeader("", "foo");
2717 headers_ir.SetHeader("foo", "bar");
2718 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
2719 if (IsSpdy2()) {
2720 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2721 } else if (IsSpdy3()) {
2722 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2723 } else {
2724 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2725 }
2726 }
2727
2728 {
2729 const char kDescription[] =
2730 "HEADERS frame with a 0-length header val, FIN, max stream ID";
2731
2732 const unsigned char kV2FrameData[] = {
2733 0x80, spdy_version_ch_, 0x00, 0x08,
2734 0x01, 0x00, 0x00, 0x19,
2735 0x7f, 0xff, 0xff, 0xff,
2736 0x00, 0x00, 0x00, 0x02,
2737 0x00, 0x03, 'b', 'a',
2738 'r', 0x00, 0x03, 'f',
2739 'o', 'o', 0x00, 0x03,
2740 'f', 'o', 'o', 0x00,
2741 0x00
2742 };
2743 const unsigned char kV3FrameData[] = {
2744 0x80, spdy_version_ch_, 0x00, 0x08,
2745 0x01, 0x00, 0x00, 0x21,
2746 0x7f, 0xff, 0xff, 0xff,
2747 0x00, 0x00, 0x00, 0x02,
2748 0x00, 0x00, 0x00, 0x03,
2749 'b', 'a', 'r', 0x00,
2750 0x00, 0x00, 0x03, 'f',
2751 'o', 'o', 0x00, 0x00,
2752 0x00, 0x03, 'f', 'o',
2753 'o', 0x00, 0x00, 0x00,
2754 0x00
2755 };
2756 const unsigned char kV4FrameData[] = {
2757 0x00, 0x0f, 0x01, 0x05, // HEADER: FIN | END_HEADERS
2758 0x7f, 0xff, 0xff, 0xff, // Stream 0x7fffffff
2759 0x00, 0x03, 0x62, 0x61, // @.ba
2760 0x72, 0x03, 0x66, 0x6f, // r.fo
2761 0x6f, 0x00, 0x03, 0x66, // o@.f
2762 0x6f, 0x6f, 0x00, // oo.
2763 };
2764 SpdyHeadersIR headers_ir(0x7fffffff);
2765 headers_ir.set_fin(true);
2766 headers_ir.SetHeader("bar", "foo");
2767 headers_ir.SetHeader("foo", "");
2768 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
2769 if (IsSpdy2()) {
2770 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2771 } else if (IsSpdy3()) {
2772 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2773 } else {
2774 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2775 }
2776 }
2777 }
2778
2779 // TODO(phajdan.jr): Clean up after we no longer need
2780 // to workaround http://crbug.com/139744.
2781 #if !defined(USE_SYSTEM_ZLIB)
2782 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
2783 SpdyFramer framer(spdy_version_);
2784 framer.set_enable_compression(true);
2785
2786 {
2787 const char kDescription[] = "HEADERS frame, no FIN";
2788
2789 const unsigned char kV2FrameData[] = {
2790 0x80, spdy_version_ch_, 0x00, 0x08,
2791 0x00, 0x00, 0x00, 0x32,
2792 0x00, 0x00, 0x00, 0x01,
2793 0x00, 0x00, 0x38, 0xea,
2794 0xdf, 0xa2, 0x51, 0xb2,
2795 0x62, 0x60, 0x62, 0x60,
2796 0x4e, 0x4a, 0x2c, 0x62,
2797 0x60, 0x06, 0x08, 0xa0,
2798 0xb4, 0xfc, 0x7c, 0x80,
2799 0x00, 0x62, 0x60, 0x4e,
2800 0xcb, 0xcf, 0x67, 0x60,
2801 0x06, 0x08, 0xa0, 0xa4,
2802 0xc4, 0x22, 0x80, 0x00,
2803 0x02, 0x00, 0x00, 0x00,
2804 0xff, 0xff,
2805 };
2806 const unsigned char kV3FrameData[] = {
2807 0x80, spdy_version_ch_, 0x00, 0x08,
2808 0x00, 0x00, 0x00, 0x31,
2809 0x00, 0x00, 0x00, 0x01,
2810 0x38, 0xea, 0xe3, 0xc6,
2811 0xa7, 0xc2, 0x02, 0xe5,
2812 0x0e, 0x50, 0xc2, 0x4b,
2813 0x4a, 0x04, 0xe5, 0x0b,
2814 0x66, 0x80, 0x00, 0x4a,
2815 0xcb, 0xcf, 0x07, 0x08,
2816 0x20, 0x10, 0x95, 0x96,
2817 0x9f, 0x0f, 0xa2, 0x00,
2818 0x02, 0x28, 0x29, 0xb1,
2819 0x08, 0x20, 0x80, 0x00,
2820 0x00, 0x00, 0x00, 0xff,
2821 0xff,
2822 };
2823 SpdyHeadersIR headers_ir(1);
2824 headers_ir.SetHeader("bar", "foo");
2825 headers_ir.SetHeader("foo", "bar");
2826 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
2827 if (IsSpdy2()) {
2828 CompareFrame(kDescription, *frame, kV2FrameData, arraysize(kV2FrameData));
2829 } else if (IsSpdy3()) {
2830 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2831 } else {
2832 // Deflate compression doesn't apply to HPACK.
2833 }
2834 }
2835 }
2836 #endif // !defined(USE_SYSTEM_ZLIB)
2837
2838 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
2839 SpdyFramer framer(spdy_version_);
2840
2841 {
2842 const char kDescription[] = "WINDOW_UPDATE frame";
2843 const unsigned char kV3FrameData[] = { // Also applies for V2.
2844 0x80, spdy_version_ch_, 0x00, 0x09,
2845 0x00, 0x00, 0x00, 0x08,
2846 0x00, 0x00, 0x00, 0x01,
2847 0x00, 0x00, 0x00, 0x01,
2848 };
2849 const unsigned char kV4FrameData[] = {
2850 0x00, 0x04, 0x08, 0x00,
2851 0x00, 0x00, 0x00, 0x01,
2852 0x00, 0x00, 0x00, 0x01,
2853 };
2854 scoped_ptr<SpdyFrame> frame(
2855 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1)));
2856 if (IsSpdy4()) {
2857 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2858 } else {
2859 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2860 }
2861 }
2862
2863 {
2864 const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
2865 const unsigned char kV3FrameData[] = { // Also applies for V2.
2866 0x80, spdy_version_ch_, 0x00, 0x09,
2867 0x00, 0x00, 0x00, 0x08,
2868 0x7f, 0xff, 0xff, 0xff,
2869 0x00, 0x00, 0x00, 0x01,
2870 };
2871 const unsigned char kV4FrameData[] = {
2872 0x00, 0x04, 0x08, 0x00,
2873 0x7f, 0xff, 0xff, 0xff,
2874 0x00, 0x00, 0x00, 0x01,
2875 };
2876 scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
2877 SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
2878 if (IsSpdy4()) {
2879 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2880 } else {
2881 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2882 }
2883 }
2884
2885 {
2886 const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
2887 const unsigned char kV3FrameData[] = { // Also applies for V2.
2888 0x80, spdy_version_ch_, 0x00, 0x09,
2889 0x00, 0x00, 0x00, 0x08,
2890 0x00, 0x00, 0x00, 0x01,
2891 0x7f, 0xff, 0xff, 0xff,
2892 };
2893 const unsigned char kV4FrameData[] = {
2894 0x00, 0x04, 0x08, 0x00,
2895 0x00, 0x00, 0x00, 0x01,
2896 0x7f, 0xff, 0xff, 0xff,
2897 };
2898 scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
2899 SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
2900 if (IsSpdy4()) {
2901 CompareFrame(kDescription, *frame, kV4FrameData, arraysize(kV4FrameData));
2902 } else {
2903 CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
2904 }
2905 }
2906 }
2907
2908 TEST_P(SpdyFramerTest, SerializeBlocked) {
2909 if (spdy_version_ <= SPDY3) {
2910 return;
2911 }
2912
2913 SpdyFramer framer(spdy_version_);
2914
2915 const char kDescription[] = "BLOCKED frame";
2916 const unsigned char kType = static_cast<unsigned char>(
2917 SpdyConstants::SerializeFrameType(spdy_version_, BLOCKED));
2918 const unsigned char kFrameData[] = {
2919 0x00, 0x00, kType, 0x00,
2920 0x00, 0x00, 0x00, 0x00,
2921 };
2922 SpdyBlockedIR blocked_ir(0);
2923 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
2924 CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
2925 }
2926
2927 TEST_P(SpdyFramerTest, CreateBlocked) {
2928 if (spdy_version_ <= SPDY3) {
2929 return;
2930 }
2931
2932 SpdyFramer framer(spdy_version_);
2933
2934 const char kDescription[] = "BLOCKED frame";
2935 const SpdyStreamId kStreamId = 3;
2936
2937 scoped_ptr<SpdySerializedFrame> frame_serialized(
2938 framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
2939 SpdyBlockedIR blocked_ir(kStreamId);
2940 scoped_ptr<SpdySerializedFrame> frame_created(
2941 framer.SerializeFrame(blocked_ir));
2942
2943 CompareFrames(kDescription, *frame_serialized, *frame_created);
2944 }
2945
2946 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
2947 if (spdy_version_ <= SPDY3) {
2948 return;
2949 }
2950
2951 SpdyFramer framer(spdy_version_);
2952 framer.set_enable_compression(false);
2953 const char kDescription[] = "PUSH_PROMISE frame";
2954
2955 const unsigned char kFrameData[] = {
2956 0x00, 0x16, 0x05, 0x04, // PUSH_PROMISE: END_HEADERS
2957 0x00, 0x00, 0x00, 0x2a, // Stream 42
2958 0x00, 0x00, 0x00, 0x39, // Promised stream 57
2959 0x00, 0x03, 0x62, 0x61, // @.ba
2960 0x72, 0x03, 0x66, 0x6f, // r.fo
2961 0x6f, 0x00, 0x03, 0x66, // o@.f
2962 0x6f, 0x6f, 0x03, 0x62, // oo.b
2963 0x61, 0x72, // ar
2964 };
2965
2966 SpdyPushPromiseIR push_promise(42, 57);
2967 push_promise.SetHeader("bar", "foo");
2968 push_promise.SetHeader("foo", "bar");
2969 scoped_ptr<SpdySerializedFrame> frame(
2970 framer.SerializePushPromise(push_promise));
2971 CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
2972 }
2973
2974 TEST_P(SpdyFramerTest, CreateAltSvc) {
2975 if (spdy_version_ <= SPDY3) {
2976 return;
2977 }
2978
2979 SpdyFramer framer(spdy_version_);
2980
2981 const char kDescription[] = "ALTSVC frame";
2982 const unsigned char kType = static_cast<unsigned char>(
2983 SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
2984 const unsigned char kFrameData[] = {
2985 0x00, 0x17, kType, 0x00,
2986 0x00, 0x00, 0x00, 0x03,
2987 0x00, 0x00, 0x00, 0x05,
2988 0x01, 0xbb, 0x00, 0x04, // Port = 443
2989 'p', 'i', 'd', '1', // Protocol-ID
2990 0x04, 'h', 'o', 's',
2991 't', 'o', 'r', 'i',
2992 'g', 'i', 'n',
2993 };
2994 SpdyAltSvcIR altsvc_ir(3);
2995 altsvc_ir.set_max_age(5);
2996 altsvc_ir.set_port(443);
2997 altsvc_ir.set_protocol_id("pid1");
2998 altsvc_ir.set_host("host");
2999 altsvc_ir.set_origin("origin");
3000 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
3001 CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
3002 }
3003
3004 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
3005 SpdyFramer framer(spdy_version_);
3006 SpdySynStreamIR syn_stream(1);
3007 syn_stream.set_priority(1);
3008 syn_stream.SetHeader("aa", "vv");
3009 syn_stream.SetHeader("bb", "ww");
3010 SpdyHeaderBlock headers = syn_stream.name_value_block();
3011 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
3012 EXPECT_TRUE(control_frame.get() != NULL);
3013 TestSpdyVisitor visitor(spdy_version_);
3014 visitor.use_compression_ = true;
3015 visitor.SimulateInFramer(
3016 reinterpret_cast<unsigned char*>(control_frame->data()),
3017 control_frame->size());
3018 EXPECT_EQ(1, visitor.syn_frame_count_);
3019 EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
3020 }
3021
3022 TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
3023 SpdyFramer framer(spdy_version_);
3024 SpdySynReplyIR syn_reply(1);
3025 syn_reply.SetHeader("alpha", "beta");
3026 syn_reply.SetHeader("gamma", "delta");
3027 SpdyHeaderBlock headers = syn_reply.name_value_block();
3028 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynReply(syn_reply));
3029 EXPECT_TRUE(control_frame.get() != NULL);
3030 TestSpdyVisitor visitor(spdy_version_);
3031 visitor.use_compression_ = true;
3032 visitor.SimulateInFramer(
3033 reinterpret_cast<unsigned char*>(control_frame->data()),
3034 control_frame->size());
3035 if (IsSpdy4()) {
3036 EXPECT_EQ(0, visitor.syn_reply_frame_count_);
3037 EXPECT_EQ(1, visitor.headers_frame_count_);
3038 } else {
3039 EXPECT_EQ(1, visitor.syn_reply_frame_count_);
3040 EXPECT_EQ(0, visitor.headers_frame_count_);
3041 }
3042 EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
3043 }
3044
3045 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
3046 SpdyFramer framer(spdy_version_);
3047 SpdyHeadersIR headers_ir(1);
3048 headers_ir.SetHeader("alpha", "beta");
3049 headers_ir.SetHeader("gamma", "delta");
3050 SpdyHeaderBlock headers = headers_ir.name_value_block();
3051 scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
3052 EXPECT_TRUE(control_frame.get() != NULL);
3053 TestSpdyVisitor visitor(spdy_version_);
3054 visitor.use_compression_ = true;
3055 visitor.SimulateInFramer(
3056 reinterpret_cast<unsigned char*>(control_frame->data()),
3057 control_frame->size());
3058 EXPECT_EQ(1, visitor.headers_frame_count_);
3059 // control_frame_header_data_count_ depends on the random sequence
3060 // produced by rand(), so adding, removing or running single tests
3061 // alters this value. The best we can do is assert that it happens
3062 // at least twice.
3063 EXPECT_LE(2, visitor.control_frame_header_data_count_);
3064 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3065 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
3066 EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
3067 }
3068
3069 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
3070 SpdyFramer framer(spdy_version_);
3071 SpdyHeadersIR headers_ir(1);
3072 headers_ir.set_fin(true);
3073 headers_ir.SetHeader("alpha", "beta");
3074 headers_ir.SetHeader("gamma", "delta");
3075 SpdyHeaderBlock headers = headers_ir.name_value_block();
3076 scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
3077 EXPECT_TRUE(control_frame.get() != NULL);
3078 TestSpdyVisitor visitor(spdy_version_);
3079 visitor.use_compression_ = true;
3080 visitor.SimulateInFramer(
3081 reinterpret_cast<unsigned char*>(control_frame->data()),
3082 control_frame->size());
3083 EXPECT_EQ(1, visitor.headers_frame_count_);
3084 // control_frame_header_data_count_ depends on the random sequence
3085 // produced by rand(), so adding, removing or running single tests
3086 // alters this value. The best we can do is assert that it happens
3087 // at least twice.
3088 EXPECT_LE(2, visitor.control_frame_header_data_count_);
3089 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3090 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
3091 EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
3092 }
3093
3094 TEST_P(SpdyFramerTest, ControlFrameAtMaxSizeLimit) {
3095 if (spdy_version_ > SPDY3) {
3096 // TODO(jgraettinger): This test setup doesn't work with HPACK.
3097 return;
3098 }
3099 // First find the size of the header value in order to just reach the control
3100 // frame max size.
3101 SpdyFramer framer(spdy_version_);
3102 framer.set_enable_compression(false);
3103 SpdySynStreamIR syn_stream(1);
3104 syn_stream.set_priority(1);
3105 syn_stream.SetHeader("aa", "");
3106 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
3107 const size_t kBigValueSize =
3108 framer.GetControlFrameBufferMaxSize() - control_frame->size();
3109
3110 // Create a frame at exactly that size.
3111 string big_value(kBigValueSize, 'x');
3112 syn_stream.SetHeader("aa", big_value);
3113 control_frame.reset(framer.SerializeSynStream(syn_stream));
3114 EXPECT_TRUE(control_frame.get() != NULL);
3115 EXPECT_EQ(framer.GetControlFrameBufferMaxSize(), control_frame->size());
3116
3117 TestSpdyVisitor visitor(spdy_version_);
3118 visitor.SimulateInFramer(
3119 reinterpret_cast<unsigned char*>(control_frame->data()),
3120 control_frame->size());
3121 EXPECT_TRUE(visitor.header_buffer_valid_);
3122 EXPECT_EQ(0, visitor.error_count_);
3123 EXPECT_EQ(1, visitor.syn_frame_count_);
3124 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3125 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
3126 EXPECT_LT(kBigValueSize, visitor.header_buffer_length_);
3127 }
3128
3129 TEST_P(SpdyFramerTest, ControlFrameTooLarge) {
3130 if (spdy_version_ > SPDY3) {
3131 // TODO(jgraettinger): This test setup doesn't work with HPACK.
3132 return;
3133 }
3134 // First find the size of the header value in order to just reach the control
3135 // frame max size.
3136 SpdyFramer framer(spdy_version_);
3137 framer.set_enable_compression(false);
3138 SpdySynStreamIR syn_stream(1);
3139 syn_stream.SetHeader("aa", "");
3140 syn_stream.set_priority(1);
3141 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
3142 const size_t kBigValueSize =
3143 framer.GetControlFrameBufferMaxSize() - control_frame->size() + 1;
3144
3145 // Create a frame at exatly that size.
3146 string big_value(kBigValueSize, 'x');
3147 syn_stream.SetHeader("aa", big_value);
3148 // Upstream branches here and wraps SPDY4 with EXPECT_DEBUG_DFATAL. We
3149 // neither support that in Chromium, nor do we use the same DFATAL (see
3150 // SpdyFrameBuilder::WriteFramePrefix()).
3151 control_frame.reset(framer.SerializeSynStream(syn_stream));
3152
3153 EXPECT_TRUE(control_frame.get() != NULL);
3154 EXPECT_EQ(framer.GetControlFrameBufferMaxSize() + 1,
3155 control_frame->size());
3156
3157 TestSpdyVisitor visitor(spdy_version_);
3158 visitor.SimulateInFramer(
3159 reinterpret_cast<unsigned char*>(control_frame->data()),
3160 control_frame->size());
3161 EXPECT_FALSE(visitor.header_buffer_valid_);
3162 EXPECT_EQ(1, visitor.error_count_);
3163 EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
3164 visitor.framer_.error_code())
3165 << SpdyFramer::ErrorCodeToString(framer.error_code());
3166 EXPECT_EQ(0, visitor.syn_frame_count_);
3167 EXPECT_EQ(0u, visitor.header_buffer_length_);
3168 }
3169
3170 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
3171 if (spdy_version_ <= SPDY3) {
3172 return;
3173 }
3174 SpdyFramer framer(spdy_version_);
3175 framer.set_enable_compression(false);
3176 SpdyHeadersIR headers(1);
3177
3178 // Exact payload length will change with HPACK, but this should be long
3179 // enough to cause an overflow.
3180 const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
3181 string big_value(kBigValueSize, 'x');
3182 headers.SetHeader("aa", big_value);
3183 scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
3184 EXPECT_TRUE(control_frame.get() != NULL);
3185 EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
3186
3187 TestSpdyVisitor visitor(spdy_version_);
3188 visitor.SimulateInFramer(
3189 reinterpret_cast<unsigned char*>(control_frame->data()),
3190 control_frame->size());
3191 EXPECT_TRUE(visitor.header_buffer_valid_);
3192 EXPECT_EQ(0, visitor.error_count_);
3193 EXPECT_EQ(1, visitor.headers_frame_count_);
3194 EXPECT_EQ(1, visitor.continuation_count_);
3195 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3196 }
3197
3198 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
3199 if (spdy_version_ <= SPDY3) {
3200 return;
3201 }
3202 SpdyFramer framer(spdy_version_);
3203 framer.set_enable_compression(false);
3204 SpdyPushPromiseIR push_promise(1, 2);
3205
3206 // Exact payload length will change with HPACK, but this should be long
3207 // enough to cause an overflow.
3208 const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
3209 string big_value(kBigValueSize, 'x');
3210 push_promise.SetHeader("aa", big_value);
3211 scoped_ptr<SpdyFrame> control_frame(
3212 framer.SerializePushPromise(push_promise));
3213 EXPECT_TRUE(control_frame.get() != NULL);
3214 EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
3215
3216 TestSpdyVisitor visitor(spdy_version_);
3217 visitor.SimulateInFramer(
3218 reinterpret_cast<unsigned char*>(control_frame->data()),
3219 control_frame->size());
3220 EXPECT_TRUE(visitor.header_buffer_valid_);
3221 EXPECT_EQ(0, visitor.error_count_);
3222 EXPECT_EQ(1, visitor.push_promise_frame_count_);
3223 EXPECT_EQ(1, visitor.continuation_count_);
3224 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3225 }
3226
3227 // Check that the framer stops delivering header data chunks once the visitor
3228 // declares it doesn't want any more. This is important to guard against
3229 // "zip bomb" types of attacks.
3230 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
3231 const size_t kHeaderBufferChunks = 4;
3232 const size_t kHeaderBufferSize =
3233 TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
3234 const size_t kBigValueSize = kHeaderBufferSize * 2;
3235 string big_value(kBigValueSize, 'x');
3236 SpdyFramer framer(spdy_version_);
3237 SpdySynStreamIR syn_stream(1);
3238 syn_stream.set_priority(1);
3239 syn_stream.set_fin(true);
3240 syn_stream.SetHeader("aa", big_value);
3241 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
3242 EXPECT_TRUE(control_frame.get() != NULL);
3243 TestSpdyVisitor visitor(spdy_version_);
3244 visitor.set_header_buffer_size(kHeaderBufferSize);
3245 visitor.use_compression_ = true;
3246 visitor.SimulateInFramer(
3247 reinterpret_cast<unsigned char*>(control_frame->data()),
3248 control_frame->size());
3249 EXPECT_FALSE(visitor.header_buffer_valid_);
3250 EXPECT_EQ(1, visitor.error_count_);
3251 EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
3252 visitor.framer_.error_code())
3253 << SpdyFramer::ErrorCodeToString(framer.error_code());
3254
3255 // The framer should have stoped delivering chunks after the visitor
3256 // signaled "stop" by returning false from OnControlFrameHeaderData().
3257 //
3258 // control_frame_header_data_count_ depends on the random sequence
3259 // produced by rand(), so adding, removing or running single tests
3260 // alters this value. The best we can do is assert that it happens
3261 // at least kHeaderBufferChunks + 1.
3262 EXPECT_LE(kHeaderBufferChunks + 1,
3263 static_cast<unsigned>(visitor.control_frame_header_data_count_));
3264 EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
3265
3266 // The framer should not have sent half-close to the visitor.
3267 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
3268 }
3269
3270 TEST_P(SpdyFramerTest, DecompressCorruptHeaderBlock) {
3271 if (spdy_version_ > SPDY3) {
3272 // Deflate compression doesn't apply to HPACK.
3273 return;
3274 }
3275 SpdyFramer framer(spdy_version_);
3276 framer.set_enable_compression(false);
3277 // Construct a SYN_STREAM control frame without compressing the header block,
3278 // and have the framer try to decompress it. This will cause the framer to
3279 // deal with a decompression error.
3280 SpdySynStreamIR syn_stream(1);
3281 syn_stream.set_priority(1);
3282 syn_stream.SetHeader("aa", "alpha beta gamma delta");
3283 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
3284 TestSpdyVisitor visitor(spdy_version_);
3285 visitor.use_compression_ = true;
3286 visitor.SimulateInFramer(
3287 reinterpret_cast<unsigned char*>(control_frame->data()),
3288 control_frame->size());
3289 EXPECT_EQ(1, visitor.error_count_);
3290 EXPECT_EQ(SpdyFramer::SPDY_DECOMPRESS_FAILURE, visitor.framer_.error_code())
3291 << SpdyFramer::ErrorCodeToString(framer.error_code());
3292 EXPECT_EQ(0u, visitor.header_buffer_length_);
3293 }
3294
3295 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
3296 SpdyFramer framer(spdy_version_);
3297 // Create a GoAway frame that has a few extra bytes at the end.
3298 // We create enough overhead to overflow the framer's control frame buffer.
3299 ASSERT_GE(250u, SpdyFramer::kControlFrameBufferSize);
3300 const unsigned char length = 1 + SpdyFramer::kControlFrameBufferSize;
3301 const unsigned char kV3FrameData[] = { // Also applies for V2.
3302 0x80, spdy_version_ch_, 0x00, 0x07,
3303 0x00, 0x00, 0x00, length,
3304 0x00, 0x00, 0x00, 0x00, // Stream ID
3305 0x00, 0x00, 0x00, 0x00, // Status
3306 };
3307
3308 // SPDY version 4 and up GOAWAY frames are only bound to a minimal length,
3309 // since it may carry opaque data. Verify that minimal length is tested.
3310 const unsigned char less_than_min_length =
3311 framer.GetGoAwayMinimumSize() - framer.GetControlFrameHeaderSize() - 1;
3312 const unsigned char kV4FrameData[] = {
3313 0x00, static_cast<uint8>(less_than_min_length), 0x07, 0x00,
3314 0x00, 0x00, 0x00, 0x00,
3315 0x00, 0x00, 0x00, 0x00, // Stream Id
3316 0x00, 0x00, 0x00, 0x00, // Status
3317 };
3318 const size_t pad_length =
3319 length + framer.GetControlFrameHeaderSize() -
3320 (IsSpdy4() ? sizeof(kV4FrameData) : sizeof(kV3FrameData));
3321 string pad('A', pad_length);
3322 TestSpdyVisitor visitor(spdy_version_);
3323
3324 if (IsSpdy4()) {
3325 visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
3326 } else {
3327 visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
3328 }
3329 visitor.SimulateInFramer(
3330 reinterpret_cast<const unsigned char*>(pad.c_str()),
3331 pad.length());
3332
3333 EXPECT_EQ(1, visitor.error_count_); // This generated an error.
3334 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
3335 visitor.framer_.error_code())
3336 << SpdyFramer::ErrorCodeToString(framer.error_code());
3337 EXPECT_EQ(0, visitor.goaway_count_); // Frame not parsed.
3338 }
3339
3340 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
3341 SpdyFramer framer(spdy_version_);
3342 SpdySettingsIR settings_ir;
3343 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
3344 SetFrameLength(control_frame.get(), 0, spdy_version_);
3345 TestSpdyVisitor visitor(spdy_version_);
3346 visitor.use_compression_ = false;
3347 visitor.SimulateInFramer(
3348 reinterpret_cast<unsigned char*>(control_frame->data()),
3349 framer.GetControlFrameHeaderSize());
3350 if (spdy_version_ <= SPDY3) {
3351 // Should generate an error, since zero-len settings frames are unsupported.
3352 EXPECT_EQ(1, visitor.error_count_);
3353 } else {
3354 // Zero-len settings frames are permitted as of SPDY 4.
3355 EXPECT_EQ(0, visitor.error_count_);
3356 }
3357 }
3358
3359 // Tests handling of SETTINGS frames with invalid length.
3360 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
3361 SpdyFramer framer(spdy_version_);
3362 SpdySettingsIR settings_ir;
3363
3364 // Add a setting to pad the frame so that we don't get a buffer overflow when
3365 // calling SimulateInFramer() below.
3366 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE,
3367 false,
3368 false,
3369 0x00000002);
3370 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
3371 const size_t kNewLength = 14;
3372 SetFrameLength(control_frame.get(), kNewLength, spdy_version_);
3373 TestSpdyVisitor visitor(spdy_version_);
3374 visitor.use_compression_ = false;
3375 visitor.SimulateInFramer(
3376 reinterpret_cast<unsigned char*>(control_frame->data()),
3377 framer.GetControlFrameHeaderSize() + kNewLength);
3378 // Should generate an error, since its not possible to have a
3379 // settings frame of length kNewLength.
3380 EXPECT_EQ(1, visitor.error_count_);
3381 }
3382
3383 // Tests handling of SETTINGS frames larger than the frame buffer size.
3384 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
3385 SpdyFramer framer(spdy_version_);
3386 SpdySettingsIR settings_ir;
3387 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
3388 false, // persist
3389 false, // persisted
3390 5);
3391 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
3392 false, // persist
3393 false, // persisted
3394 6);
3395 settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
3396 false, // persist
3397 false, // persisted
3398 7);
3399
3400 scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
3401 EXPECT_LT(SpdyFramer::kControlFrameBufferSize,
3402 control_frame->size());
3403 TestSpdyVisitor visitor(spdy_version_);
3404 visitor.use_compression_ = false;
3405
3406 // Read all at once.
3407 visitor.SimulateInFramer(
3408 reinterpret_cast<unsigned char*>(control_frame->data()),
3409 control_frame->size());
3410 EXPECT_EQ(0, visitor.error_count_);
3411 EXPECT_EQ(3, visitor.setting_count_);
3412 if (spdy_version_ > SPDY3) {
3413 EXPECT_EQ(1, visitor.settings_ack_sent_);
3414 }
3415
3416 // Read data in small chunks.
3417 size_t framed_data = 0;
3418 size_t unframed_data = control_frame->size();
3419 size_t kReadChunkSize = 5; // Read five bytes at a time.
3420 while (unframed_data > 0) {
3421 size_t to_read = min(kReadChunkSize, unframed_data);
3422 visitor.SimulateInFramer(
3423 reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
3424 to_read);
3425 unframed_data -= to_read;
3426 framed_data += to_read;
3427 }
3428 EXPECT_EQ(0, visitor.error_count_);
3429 EXPECT_EQ(3 * 2, visitor.setting_count_);
3430 if (spdy_version_ > SPDY3) {
3431 EXPECT_EQ(2, visitor.settings_ack_sent_);
3432 }
3433 }
3434
3435 // Tests handling of SETTINGS frame with duplicate entries.
3436 TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
3437 SpdyFramer framer(spdy_version_);
3438
3439 const unsigned char kV2FrameData[] = {
3440 0x80, spdy_version_ch_, 0x00, 0x04,
3441 0x00, 0x00, 0x00, 0x1C,
3442 0x00, 0x00, 0x00, 0x03,
3443 0x01, 0x00, 0x00, 0x00, // 1st Setting
3444 0x00, 0x00, 0x00, 0x02,
3445 0x01, 0x00, 0x00, 0x00, // 2nd (duplicate) Setting
3446 0x00, 0x00, 0x00, 0x03,
3447 0x03, 0x00, 0x00, 0x00, // 3rd (unprocessed) Setting
3448 0x00, 0x00, 0x00, 0x03,
3449 };
3450 const unsigned char kV3FrameData[] = {
3451 0x80, spdy_version_ch_, 0x00, 0x04,
3452 0x00, 0x00, 0x00, 0x1C,
3453 0x00, 0x00, 0x00, 0x03,
3454 0x00, 0x00, 0x00, 0x01, // 1st Setting
3455 0x00, 0x00, 0x00, 0x02,
3456 0x00, 0x00, 0x00, 0x01, // 2nd (duplicate) Setting
3457 0x00, 0x00, 0x00, 0x03,
3458 0x00, 0x00, 0x00, 0x03, // 3rd (unprocessed) Setting
3459 0x00, 0x00, 0x00, 0x03,
3460 };
3461 const unsigned char kV4FrameData[] = {
3462 0x00, 0x0f, 0x04, 0x00,
3463 0x00, 0x00, 0x00, 0x00,
3464 0x01, // 1st Setting
3465 0x00, 0x00, 0x00, 0x02,
3466 0x01, // 2nd (duplicate) Setting
3467 0x00, 0x00, 0x00, 0x03,
3468 0x03, // 3rd (unprocessed) Setting
3469 0x00, 0x00, 0x00, 0x03,
3470 };
3471
3472 TestSpdyVisitor visitor(spdy_version_);
3473 visitor.use_compression_ = false;
3474 if (IsSpdy2()) {
3475 visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
3476 } else if (IsSpdy3()) {
3477 visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
3478 } else {
3479 visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
3480 }
3481
3482 if (!IsSpdy4()) {
3483 EXPECT_EQ(1, visitor.setting_count_);
3484 EXPECT_EQ(1, visitor.error_count_);
3485 } else {
3486 // In SPDY 4+, duplicate settings are allowed;
3487 // each setting replaces the previous value for that setting.
3488 EXPECT_EQ(3, visitor.setting_count_);
3489 EXPECT_EQ(0, visitor.error_count_);
3490 EXPECT_EQ(1, visitor.settings_ack_sent_);
3491 }
3492 }
3493
3494 // Tests handling of SETTINGS_COMPRESS_DATA.
3495 TEST_P(SpdyFramerTest, AcceptSettingsCompressData) {
3496 if (!IsSpdy4()) { return; }
3497 SpdyFramer framer(spdy_version_);
3498
3499 const unsigned char kFrameData[] = {
3500 0x00, 0x05, 0x04, 0x00,
3501 0x00, 0x00, 0x00, 0x00,
3502 0x05, 0x00, 0x00, 0x00,
3503 0x01,
3504 };
3505
3506 TestSpdyVisitor visitor(spdy_version_);
3507 visitor.use_compression_ = false;
3508 visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
3509 EXPECT_EQ(1, visitor.setting_count_);
3510 EXPECT_EQ(0, visitor.error_count_);
3511 }
3512
3513 // Tests handling of SETTINGS frame with entries out of order.
3514 TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
3515 SpdyFramer framer(spdy_version_);
3516
3517 const unsigned char kV2FrameData[] = {
3518 0x80, spdy_version_ch_, 0x00, 0x04,
3519 0x00, 0x00, 0x00, 0x1C,
3520 0x00, 0x00, 0x00, 0x03,
3521 0x02, 0x00, 0x00, 0x00, // 1st Setting
3522 0x00, 0x00, 0x00, 0x02,
3523 0x01, 0x00, 0x00, 0x00, // 2nd (out of order) Setting
3524 0x00, 0x00, 0x00, 0x03,
3525 0x03, 0x00, 0x00, 0x00, // 3rd (unprocessed) Setting
3526 0x00, 0x00, 0x00, 0x03,
3527 };
3528 const unsigned char kV3FrameData[] = {
3529 0x80, spdy_version_ch_, 0x00, 0x04,
3530 0x00, 0x00, 0x00, 0x1C,
3531 0x00, 0x00, 0x00, 0x03,
3532 0x00, 0x00, 0x00, 0x02, // 1st Setting
3533 0x00, 0x00, 0x00, 0x02,
3534 0x00, 0x00, 0x00, 0x01, // 2nd (out of order) Setting
3535 0x00, 0x00, 0x00, 0x03,
3536 0x00, 0x00, 0x01, 0x03, // 3rd (unprocessed) Setting
3537 0x00, 0x00, 0x00, 0x03,
3538 };
3539 const unsigned char kV4FrameData[] = {
3540 0x00, 0x0f, 0x04, 0x00,
3541 0x00, 0x00, 0x00, 0x00,
3542 0x02, // 1st Setting
3543 0x00, 0x00, 0x00, 0x02,
3544 0x01, // 2nd (out of order) Setting
3545 0x00, 0x00, 0x00, 0x03,
3546 0x03, // 3rd (unprocessed) Setting
3547 0x00, 0x00, 0x00, 0x03,
3548 };
3549
3550 TestSpdyVisitor visitor(spdy_version_);
3551 visitor.use_compression_ = false;
3552 if (IsSpdy2()) {
3553 visitor.SimulateInFramer(kV2FrameData, sizeof(kV2FrameData));
3554 } else if (IsSpdy3()) {
3555 visitor.SimulateInFramer(kV3FrameData, sizeof(kV3FrameData));
3556 } else {
3557 visitor.SimulateInFramer(kV4FrameData, sizeof(kV4FrameData));
3558 }
3559
3560 if (!IsSpdy4()) {
3561 EXPECT_EQ(1, visitor.setting_count_);
3562 EXPECT_EQ(1, visitor.error_count_);
3563 } else {
3564 // In SPDY 4+, settings are allowed in any order.
3565 EXPECT_EQ(3, visitor.setting_count_);
3566 EXPECT_EQ(0, visitor.error_count_);
3567 // EXPECT_EQ(1, visitor.settings_ack_count_);
3568 }
3569 }
3570
3571 TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
3572 if (spdy_version_ <= SPDY3) {
3573 return;
3574 }
3575 SpdyFramer framer(spdy_version_);
3576
3577 const unsigned char kFrameData[] = {
3578 0x00, 0x00, 0x04, 0x01,
3579 0x00, 0x00, 0x00, 0x00,
3580 };
3581
3582 TestSpdyVisitor visitor(spdy_version_);
3583 visitor.use_compression_ = false;
3584 visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
3585
3586 EXPECT_EQ(0, visitor.error_count_);
3587 EXPECT_EQ(0, visitor.setting_count_);
3588 EXPECT_EQ(1, visitor.settings_ack_received_);
3589 }
3590
3591
3592 TEST_P(SpdyFramerTest, ProcessDataFrameWithPadding) {
3593 if (spdy_version_ <= SPDY3) {
3594 return;
3595 }
3596
3597 const int kPaddingLen = 512; // So we get two bytes for padding length field.
3598 const char data_payload[] = "hello";
3599
3600 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
3601 SpdyFramer framer(spdy_version_);
3602 framer.set_visitor(&visitor);
3603
3604 SpdyDataIR data_ir(1, StringPiece(data_payload, strlen(data_payload)));
3605 data_ir.set_padding_len(kPaddingLen);
3606 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
3607 ASSERT_TRUE(frame.get() != NULL);
3608
3609 int bytes_consumed = 0;
3610
3611 // Send the frame header.
3612 EXPECT_CALL(visitor, OnDataFrameHeader(1,
3613 kPaddingLen + strlen(data_payload),
3614 false));
3615 CHECK_EQ(8u, framer.ProcessInput(frame->data(), 8));
3616 CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_PADDING_LENGTH);
3617 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3618 bytes_consumed += 8;
3619
3620 // Send the first byte of the padding length field.
3621 CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
3622 CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_PADDING_LENGTH);
3623 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3624 bytes_consumed += 1;
3625
3626 // Send the second byte of the padding length field.
3627 CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
3628 CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
3629 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3630 bytes_consumed += 1;
3631
3632 // Send the first two bytes of the data payload.
3633 EXPECT_CALL(visitor, OnStreamFrameData(1, _, 2, false));
3634 CHECK_EQ(2u, framer.ProcessInput(frame->data() + bytes_consumed, 2));
3635 CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
3636 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3637 bytes_consumed += 2;
3638
3639 // Send the rest three bytes of the data payload.
3640 EXPECT_CALL(visitor, OnStreamFrameData(1, _, 3, false));
3641 CHECK_EQ(3u, framer.ProcessInput(frame->data() + bytes_consumed, 3));
3642 CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
3643 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3644 bytes_consumed += 3;
3645
3646 // Send the first 100 bytes of the padding payload.
3647 EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 100, false));
3648 CHECK_EQ(100u, framer.ProcessInput(frame->data() + bytes_consumed, 100));
3649 CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
3650 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3651 bytes_consumed += 100;
3652
3653 // Send rest of the padding payload.
3654 EXPECT_CALL(visitor, OnStreamFrameData(1, NULL, 410, false));
3655 CHECK_EQ(410u, framer.ProcessInput(frame->data() + bytes_consumed, 410));
3656 CHECK_EQ(framer.state(), SpdyFramer::SPDY_RESET);
3657 CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
3658 }
3659
3660 TEST_P(SpdyFramerTest, ReadWindowUpdate) {
3661 SpdyFramer framer(spdy_version_);
3662 scoped_ptr<SpdyFrame> control_frame(
3663 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
3664 TestSpdyVisitor visitor(spdy_version_);
3665 visitor.SimulateInFramer(
3666 reinterpret_cast<unsigned char*>(control_frame->data()),
3667 control_frame->size());
3668 EXPECT_EQ(1u, visitor.last_window_update_stream_);
3669 EXPECT_EQ(2u, visitor.last_window_update_delta_);
3670 }
3671
3672 TEST_P(SpdyFramerTest, ReceiveCredentialFrame) {
3673 if (!IsSpdy3()) {
3674 return;
3675 }
3676 SpdyFramer framer(spdy_version_);
3677 const unsigned char kV3FrameData[] = { // Also applies for V2.
3678 0x80, spdy_version_ch_, 0x00, 0x0A,
3679 0x00, 0x00, 0x00, 0x33,
3680 0x00, 0x03, 0x00, 0x00,
3681 0x00, 0x05, 'p', 'r',
3682 'o', 'o', 'f', 0x00,
3683 0x00, 0x00, 0x06, 'a',
3684 ' ', 'c', 'e', 'r',
3685 't', 0x00, 0x00, 0x00,
3686 0x0C, 'a', 'n', 'o',
3687 't', 'h', 'e', 'r',
3688 ' ', 'c', 'e', 'r',
3689 't', 0x00, 0x00, 0x00,
3690 0x0A, 'f', 'i', 'n',
3691 'a', 'l', ' ', 'c',
3692 'e', 'r', 't',
3693 };
3694 TestSpdyVisitor visitor(spdy_version_);
3695 visitor.use_compression_ = false;
3696 visitor.SimulateInFramer(kV3FrameData, arraysize(kV3FrameData));
3697 EXPECT_EQ(0, visitor.error_count_);
3698 }
3699
3700 TEST_P(SpdyFramerTest, ReadCredentialFrameFollowedByAnotherFrame) {
3701 if (!IsSpdy3()) {
3702 return;
3703 }
3704 SpdyFramer framer(spdy_version_);
3705 const unsigned char kV3FrameData[] = { // Also applies for V2.
3706 0x80, spdy_version_ch_, 0x00, 0x0A,
3707 0x00, 0x00, 0x00, 0x33,
3708 0x00, 0x03, 0x00, 0x00,
3709 0x00, 0x05, 'p', 'r',
3710 'o', 'o', 'f', 0x00,
3711 0x00, 0x00, 0x06, 'a',
3712 ' ', 'c', 'e', 'r',
3713 't', 0x00, 0x00, 0x00,
3714 0x0C, 'a', 'n', 'o',
3715 't', 'h', 'e', 'r',
3716 ' ', 'c', 'e', 'r',
3717 't', 0x00, 0x00, 0x00,
3718 0x0A, 'f', 'i', 'n',
3719 'a', 'l', ' ', 'c',
3720 'e', 'r', 't',
3721 };
3722 TestSpdyVisitor visitor(spdy_version_);
3723 visitor.use_compression_ = false;
3724 string multiple_frame_data(reinterpret_cast<const char*>(kV3FrameData),
3725 arraysize(kV3FrameData));
3726 scoped_ptr<SpdyFrame> control_frame(
3727 framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
3728 multiple_frame_data.append(string(control_frame->data(),
3729 control_frame->size()));
3730 visitor.SimulateInFramer(
3731 reinterpret_cast<unsigned const char*>(multiple_frame_data.data()),
3732 multiple_frame_data.length());
3733 EXPECT_EQ(0, visitor.error_count_);
3734 EXPECT_EQ(1u, visitor.last_window_update_stream_);
3735 EXPECT_EQ(2u, visitor.last_window_update_delta_);
3736 }
3737
3738 TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
3739 if (spdy_version_ <= SPDY3) {
3740 return;
3741 }
3742
3743 SpdyFramer framer(spdy_version_);
3744 framer.set_enable_compression(false);
3745 const char kDescription[] = "CONTINUATION frame";
3746
3747 const unsigned char kFrameData[] = {
3748 0x00, 0x12, 0x09, 0x00, // CONTINUATION
3749 0x00, 0x00, 0x00, 0x2a, // Stream 42
3750 0x00, 0x03, 0x62, 0x61, // @.ba
3751 0x72, 0x03, 0x66, 0x6f, // r.fo
3752 0x6f, 0x00, 0x03, 0x66, // o@.f
3753 0x6f, 0x6f, 0x03, 0x62, // oo.b
3754 0x61, 0x72, // ar
3755 };
3756
3757 SpdyContinuationIR continuation(42);
3758 continuation.SetHeader("bar", "foo");
3759 continuation.SetHeader("foo", "bar");
3760 scoped_ptr<SpdySerializedFrame> frame(
3761 framer.SerializeContinuation(continuation));
3762 CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
3763 }
3764
3765 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
3766 if (spdy_version_ <= SPDY3) {
3767 return;
3768 }
3769
3770 SpdyFramer framer(spdy_version_);
3771 SpdyPushPromiseIR push_promise(42, 57);
3772 push_promise.SetHeader("foo", "bar");
3773 push_promise.SetHeader("bar", "foofoo");
3774 SpdyHeaderBlock headers = push_promise.name_value_block();
3775 scoped_ptr<SpdySerializedFrame> frame(
3776 framer.SerializePushPromise(push_promise));
3777 EXPECT_TRUE(frame.get() != NULL);
3778 TestSpdyVisitor visitor(spdy_version_);
3779 visitor.use_compression_ = true;
3780 visitor.SimulateInFramer(
3781 reinterpret_cast<unsigned char*>(frame->data()),
3782 frame->size());
3783 EXPECT_EQ(42u, visitor.last_push_promise_stream_);
3784 EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
3785 EXPECT_TRUE(CompareHeaderBlocks(&headers, &visitor.headers_));
3786 }
3787
3788 TEST_P(SpdyFramerTest, ReadHeadersWithContinuationAndPadding) {
3789 if (spdy_version_ <= SPDY3) {
3790 return;
3791 }
3792
3793 const unsigned char kInput[] = {
3794 0x00, 0x14, 0x01, 0x08, // HEADERS: PAD_LOW
3795 0x00, 0x00, 0x00, 0x01, // Stream 1
3796 0x03, // Padding of 3.
3797 0x00, 0x06, 0x63, 0x6f,
3798 0x6f, 0x6b, 0x69, 0x65,
3799 0x07, 0x66, 0x6f, 0x6f,
3800 0x3d, 0x62, 0x61, 0x72,
3801 0x00, 0x00, 0x00,
3802
3803 0x00, 0x1a, 0x09, 0x18, // CONTINUATION: PAD_LOW & PAD_HIGH
3804 0x00, 0x00, 0x00, 0x01, // Stream 1
3805 0x00, 0x04, // Padding of 4.
3806 0x00, 0x06, 0x63, 0x6f,
3807 0x6f, 0x6b, 0x69, 0x65,
3808 0x08, 0x62, 0x61, 0x7a,
3809 0x3d, 0x62, 0x69, 0x6e,
3810 0x67, 0x00, 0x06, 0x63,
3811 0x00, 0x00, 0x00, 0x00,
3812
3813 0x00, 0x13, 0x09, 0x0c, // CONTINUATION: PAD_LOW & END_HEADERS
3814 0x00, 0x00, 0x00, 0x01, // Stream 1
3815 0x00, // Padding of 0.
3816 0x6f, 0x6f, 0x6b, 0x69,
3817 0x65, 0x00, 0x00, 0x04,
3818 0x6e, 0x61, 0x6d, 0x65,
3819 0x05, 0x76, 0x61, 0x6c,
3820 0x75, 0x65,
3821 };
3822
3823 TestSpdyVisitor visitor(spdy_version_);
3824 visitor.SimulateInFramer(kInput, sizeof(kInput));
3825
3826 EXPECT_EQ(0, visitor.error_count_);
3827 EXPECT_EQ(1, visitor.headers_frame_count_);
3828 EXPECT_EQ(2, visitor.continuation_count_);
3829 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3830 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
3831
3832 EXPECT_THAT(visitor.headers_, ElementsAre(
3833 Pair("cookie", "foo=bar; baz=bing; "),
3834 Pair("name", "value")));
3835 }
3836
3837 TEST_P(SpdyFramerTest, ReadHeadersWithContinuationAndFin) {
3838 if (spdy_version_ <= SPDY3) {
3839 return;
3840 }
3841
3842 const unsigned char kInput[] = {
3843 0x00, 0x10, 0x01, 0x01, // HEADERS: FIN
3844 0x00, 0x00, 0x00, 0x01, // Stream 1
3845 0x00, 0x06, 0x63, 0x6f,
3846 0x6f, 0x6b, 0x69, 0x65,
3847 0x07, 0x66, 0x6f, 0x6f,
3848 0x3d, 0x62, 0x61, 0x72,
3849
3850 0x00, 0x14, 0x09, 0x00, // CONTINUATION
3851 0x00, 0x00, 0x00, 0x01, // Stream 1
3852 0x00, 0x06, 0x63, 0x6f,
3853 0x6f, 0x6b, 0x69, 0x65,
3854 0x08, 0x62, 0x61, 0x7a,
3855 0x3d, 0x62, 0x69, 0x6e,
3856 0x67, 0x00, 0x06, 0x63,
3857
3858 0x00, 0x12, 0x09, 0x04, // CONTINUATION: END_HEADERS
3859 0x00, 0x00, 0x00, 0x01, // Stream 1
3860 0x6f, 0x6f, 0x6b, 0x69,
3861 0x65, 0x00, 0x00, 0x04,
3862 0x6e, 0x61, 0x6d, 0x65,
3863 0x05, 0x76, 0x61, 0x6c,
3864 0x75, 0x65,
3865 };
3866
3867 SpdyFramer framer(spdy_version_);
3868 TestSpdyVisitor visitor(spdy_version_);
3869 visitor.SimulateInFramer(kInput, sizeof(kInput));
3870
3871 EXPECT_EQ(0, visitor.error_count_);
3872 EXPECT_EQ(1, visitor.headers_frame_count_);
3873 EXPECT_EQ(2, visitor.continuation_count_);
3874 EXPECT_EQ(1, visitor.fin_flag_count_);
3875 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3876 EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
3877
3878 EXPECT_THAT(visitor.headers_, ElementsAre(
3879 Pair("cookie", "foo=bar; baz=bing; "),
3880 Pair("name", "value")));
3881 }
3882
3883 TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuationAndPadding) {
3884 if (spdy_version_ <= SPDY3) {
3885 return;
3886 }
3887
3888 const unsigned char kInput[] = {
3889 0x00, 0x18, 0x05, 0x18, // PUSH_PROMISE: PAD_LOW & PAD_HIGH
3890 0x00, 0x00, 0x00, 0x01, // Stream 1
3891 0x00, 0x00, 0x00, 0x2A, // Promised stream 42
3892 0x00, 0x02, // Padding of 2.
3893 0x00, 0x06, 0x63, 0x6f,
3894 0x6f, 0x6b, 0x69, 0x65,
3895 0x07, 0x66, 0x6f, 0x6f,
3896 0x3d, 0x62, 0x61, 0x72,
3897 0x00, 0x00,
3898
3899 0x00, 0x14, 0x09, 0x00, // CONTINUATION:
3900 0x00, 0x00, 0x00, 0x01, // Stream 1
3901 0x00, 0x06, 0x63, 0x6f,
3902 0x6f, 0x6b, 0x69, 0x65,
3903 0x08, 0x62, 0x61, 0x7a,
3904 0x3d, 0x62, 0x69, 0x6e,
3905 0x67, 0x00, 0x06, 0x63,
3906
3907 0x00, 0x17, 0x09, 0x0c, // CONTINUATION: PAD_LOW & END_HEADERS
3908 0x00, 0x00, 0x00, 0x01, // Stream 1
3909 0x04, // Padding of 4.
3910 0x6f, 0x6f, 0x6b, 0x69,
3911 0x65, 0x00, 0x00, 0x04,
3912 0x6e, 0x61, 0x6d, 0x65,
3913 0x05, 0x76, 0x61, 0x6c,
3914 0x75, 0x65, 0x00, 0x00,
3915 0x00, 0x00,
3916 };
3917
3918 SpdyFramer framer(spdy_version_);
3919 TestSpdyVisitor visitor(spdy_version_);
3920 visitor.SimulateInFramer(kInput, sizeof(kInput));
3921
3922 EXPECT_EQ(0, visitor.error_count_);
3923 EXPECT_EQ(1u, visitor.last_push_promise_stream_);
3924 EXPECT_EQ(42u, visitor.last_push_promise_promised_stream_);
3925 EXPECT_EQ(2, visitor.continuation_count_);
3926 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
3927 EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
3928
3929 EXPECT_THAT(visitor.headers_, ElementsAre(
3930 Pair("cookie", "foo=bar; baz=bing; "),
3931 Pair("name", "value")));
3932 }
3933
3934 TEST_P(SpdyFramerTest, ReadContinuationWithWrongStreamId) {
3935 if (spdy_version_ <= SPDY3) {
3936 return;
3937 }
3938
3939 const unsigned char kInput[] = {
3940 0x00, 0x10, 0x01, 0x00, // HEADERS
3941 0x00, 0x00, 0x00, 0x01, // Stream 1
3942 0x00, 0x06, 0x63, 0x6f,
3943 0x6f, 0x6b, 0x69, 0x65,
3944 0x07, 0x66, 0x6f, 0x6f,
3945 0x3d, 0x62, 0x61, 0x72,
3946
3947 0x00, 0x14, 0x09, 0x00, // CONTINUATION
3948 0x00, 0x00, 0x00, 0x02, // Stream 2
3949 0x00, 0x06, 0x63, 0x6f,
3950 0x6f, 0x6b, 0x69, 0x65,
3951 0x08, 0x62, 0x61, 0x7a,
3952 0x3d, 0x62, 0x69, 0x6e,
3953 0x67, 0x00, 0x06, 0x63,
3954 };
3955
3956 SpdyFramer framer(spdy_version_);
3957 TestSpdyVisitor visitor(spdy_version_);
3958 framer.set_visitor(&visitor);
3959 visitor.SimulateInFramer(kInput, sizeof(kInput));
3960
3961 EXPECT_EQ(1, visitor.error_count_);
3962 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
3963 visitor.framer_.error_code())
3964 << SpdyFramer::ErrorCodeToString(framer.error_code());
3965 EXPECT_EQ(1, visitor.headers_frame_count_);
3966 EXPECT_EQ(0, visitor.continuation_count_);
3967 EXPECT_EQ(0u, visitor.header_buffer_length_);
3968 }
3969
3970 TEST_P(SpdyFramerTest, ReadContinuationOutOfOrder) {
3971 if (spdy_version_ <= SPDY3) {
3972 return;
3973 }
3974
3975 const unsigned char kInput[] = {
3976 0x00, 0x10, 0x09, 0x00, // CONTINUATION
3977 0x00, 0x00, 0x00, 0x01, // Stream 1
3978 0x00, 0x06, 0x63, 0x6f,
3979 0x6f, 0x6b, 0x69, 0x65,
3980 0x07, 0x66, 0x6f, 0x6f,
3981 0x3d, 0x62, 0x61, 0x72,
3982 };
3983
3984 SpdyFramer framer(spdy_version_);
3985 TestSpdyVisitor visitor(spdy_version_);
3986 framer.set_visitor(&visitor);
3987 visitor.SimulateInFramer(kInput, sizeof(kInput));
3988
3989 EXPECT_EQ(1, visitor.error_count_);
3990 EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
3991 visitor.framer_.error_code())
3992 << SpdyFramer::ErrorCodeToString(framer.error_code());
3993 EXPECT_EQ(0, visitor.continuation_count_);
3994 EXPECT_EQ(0u, visitor.header_buffer_length_);
3995 }
3996
3997 TEST_P(SpdyFramerTest, ExpectContinuationReceiveData) {
3998 if (spdy_version_ <= SPDY3) {
3999 return;
4000 }
4001
4002 const unsigned char kInput[] = {
4003 0x00, 0x10, 0x01, 0x00, // HEADERS
4004 0x00, 0x00, 0x00, 0x01, // Stream 1
4005 0x00, 0x06, 0x63, 0x6f,
4006 0x6f, 0x6b, 0x69, 0x65,
4007 0x07, 0x66, 0x6f, 0x6f,
4008 0x3d, 0x62, 0x61, 0x72,
4009
4010 0x00, 0x00, 0x00, 0x01, // DATA on Stream #1
4011 0x00, 0x00, 0x00, 0x04,
4012 0xde, 0xad, 0xbe, 0xef,
4013 };
4014
4015 SpdyFramer framer(spdy_version_);
4016 TestSpdyVisitor visitor(spdy_version_);
4017 framer.set_visitor(&visitor);
4018 visitor.SimulateInFramer(kInput, sizeof(kInput));
4019
4020 EXPECT_EQ(1, visitor.error_count_);
4021 EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
4022 visitor.framer_.error_code())
4023 << SpdyFramer::ErrorCodeToString(framer.error_code());
4024 EXPECT_EQ(1, visitor.headers_frame_count_);
4025 EXPECT_EQ(0, visitor.continuation_count_);
4026 EXPECT_EQ(0u, visitor.header_buffer_length_);
4027 EXPECT_EQ(0, visitor.data_frame_count_);
4028 }
4029
4030 TEST_P(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
4031 if (spdy_version_ <= SPDY3) {
4032 return;
4033 }
4034
4035 const unsigned char kInput[] = {
4036 0x00, 0x10, 0x01, 0x00, // HEADERS
4037 0x00, 0x00, 0x00, 0x01, // Stream 1
4038 0x00, 0x06, 0x63, 0x6f,
4039 0x6f, 0x6b, 0x69, 0x65,
4040 0x07, 0x66, 0x6f, 0x6f,
4041 0x3d, 0x62, 0x61, 0x72,
4042
4043 0x00, 0x14, 0x08, 0x00, // HEADERS
4044 0x00, 0x00, 0x00, 0x01, // Stream 1
4045 0x00, 0x06, 0x63, 0x6f, // (Note this is a valid continued encoding).
4046 0x6f, 0x6b, 0x69, 0x65,
4047 0x08, 0x62, 0x61, 0x7a,
4048 0x3d, 0x62, 0x69, 0x6e,
4049 0x67, 0x00, 0x06, 0x63,
4050 };
4051
4052 SpdyFramer framer(spdy_version_);
4053 TestSpdyVisitor visitor(spdy_version_);
4054 framer.set_visitor(&visitor);
4055 visitor.SimulateInFramer(kInput, sizeof(kInput));
4056
4057 EXPECT_EQ(1, visitor.error_count_);
4058 EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME,
4059 visitor.framer_.error_code())
4060 << SpdyFramer::ErrorCodeToString(framer.error_code());
4061 EXPECT_EQ(1, visitor.headers_frame_count_);
4062 EXPECT_EQ(0, visitor.continuation_count_);
4063 EXPECT_EQ(0u, visitor.header_buffer_length_);
4064 EXPECT_EQ(0, visitor.data_frame_count_);
4065 }
4066
4067 TEST_P(SpdyFramerTest, EndSegmentOnDataFrame) {
4068 if (spdy_version_ <= SPDY3) {
4069 return;
4070 }
4071 const unsigned char kInput[] = {
4072 0x00, 0x0c, 0x00, 0x02, // DATA: END_SEGMENT
4073 0x00, 0x00, 0x00, 0x01, // Stream 1
4074 0xde, 0xad, 0xbe, 0xef,
4075 0xde, 0xad, 0xbe, 0xef,
4076 0xde, 0xad, 0xbe, 0xef,
4077 };
4078
4079 TestSpdyVisitor visitor(spdy_version_);
4080 visitor.SimulateInFramer(kInput, sizeof(kInput));
4081
4082 // TODO(jgraettinger): Verify END_SEGMENT when support is added.
4083 EXPECT_EQ(0, visitor.error_count_);
4084 EXPECT_EQ(12, visitor.data_bytes_);
4085 EXPECT_EQ(0, visitor.fin_frame_count_);
4086 EXPECT_EQ(0, visitor.fin_flag_count_);
4087 }
4088
4089 TEST_P(SpdyFramerTest, EndSegmentOnHeadersFrame) {
4090 if (spdy_version_ <= SPDY3) {
4091 return;
4092 }
4093 const unsigned char kInput[] = {
4094 0x00, 0x10, 0x01, 0x06, // HEADERS: END_SEGMENT | END_HEADERS
4095 0x00, 0x00, 0x00, 0x01, // Stream 1
4096 0x00, 0x06, 0x63, 0x6f,
4097 0x6f, 0x6b, 0x69, 0x65,
4098 0x07, 0x66, 0x6f, 0x6f,
4099 0x3d, 0x62, 0x61, 0x72,
4100 };
4101
4102 TestSpdyVisitor visitor(spdy_version_);
4103 visitor.SimulateInFramer(kInput, sizeof(kInput));
4104
4105 // TODO(jgraettinger): Verify END_SEGMENT when support is added.
4106 EXPECT_EQ(0, visitor.error_count_);
4107 EXPECT_EQ(1, visitor.headers_frame_count_);
4108 EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
4109
4110 EXPECT_THAT(visitor.headers_, ElementsAre(
4111 Pair("cookie", "foo=bar")));
4112 }
4113
4114 TEST_P(SpdyFramerTest, ReadGarbage) {
4115 SpdyFramer framer(spdy_version_);
4116 unsigned char garbage_frame[256];
4117 memset(garbage_frame, ~0, sizeof(garbage_frame));
4118 TestSpdyVisitor visitor(spdy_version_);
4119 visitor.use_compression_ = false;
4120 visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
4121 EXPECT_EQ(1, visitor.error_count_);
4122 }
4123
4124 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
4125 if (!IsSpdy4()) {
4126 return;
4127 }
4128 SpdyFramer framer(spdy_version_);
4129 const unsigned char kFrameData[] = {
4130 0x00, 0x10, 0xff, 0xff,
4131 0xff, 0xff, 0xff, 0xff,
4132 0xff, 0xff, 0xff, 0xff,
4133 0xff, 0xff, 0xff, 0xff,
4134 };
4135 TestSpdyVisitor visitor(spdy_version_);
4136 visitor.use_compression_ = false;
4137 visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
4138 EXPECT_EQ(1, visitor.error_count_);
4139 }
4140
4141 TEST_P(SpdyFramerTest, ReadGarbageWithValidVersion) {
4142 if (IsSpdy4()) {
4143 // Not valid for SPDY 4 since there is no version field.
4144 return;
4145 }
4146 SpdyFramer framer(spdy_version_);
4147 const unsigned char kFrameData[] = {
4148 0x80, spdy_version_ch_, 0xff, 0xff,
4149 0xff, 0xff, 0xff, 0xff,
4150 };
4151 TestSpdyVisitor visitor(spdy_version_);
4152 visitor.use_compression_ = false;
4153 visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
4154 EXPECT_EQ(1, visitor.error_count_);
4155 }
4156
4157 TEST_P(SpdyFramerTest, ReadGarbageHPACKEncoding) {
4158 if (spdy_version_ <= SPDY3) {
4159 return;
4160 }
4161 const unsigned char kInput[] = {
4162 0x00, 0x12, 0x01, 0x04, // HEADER: END_HEADERS
4163 0x00, 0x00, 0x00, 0x01, // Stream 1
4164 0xef, 0xef, 0xff, 0xff,
4165 0xff, 0xff, 0xff, 0xff,
4166 0xff, 0xff, 0xff, 0xff,
4167 0xff, 0xff, 0xff, 0xff,
4168 0xff, 0xff,
4169 };
4170
4171 TestSpdyVisitor visitor(spdy_version_);
4172 visitor.SimulateInFramer(kInput, arraysize(kInput));
4173 EXPECT_EQ(1, visitor.error_count_);
4174 }
4175
4176 TEST_P(SpdyFramerTest, SizesTest) {
4177 SpdyFramer framer(spdy_version_);
4178 EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
4179 if (IsSpdy4() || IsSpdy5()) {
4180 EXPECT_EQ(8u, framer.GetSynReplyMinimumSize());
4181 EXPECT_EQ(12u, framer.GetRstStreamMinimumSize());
4182 EXPECT_EQ(8u, framer.GetSettingsMinimumSize());
4183 EXPECT_EQ(16u, framer.GetPingSize());
4184 EXPECT_EQ(16u, framer.GetGoAwayMinimumSize());
4185 EXPECT_EQ(8u, framer.GetHeadersMinimumSize());
4186 EXPECT_EQ(12u, framer.GetWindowUpdateSize());
4187 EXPECT_EQ(8u, framer.GetBlockedSize());
4188 EXPECT_EQ(12u, framer.GetPushPromiseMinimumSize());
4189 EXPECT_EQ(17u, framer.GetAltSvcMinimumSize());
4190 EXPECT_EQ(8u, framer.GetFrameMinimumSize());
4191 EXPECT_EQ(16383u, framer.GetFrameMaximumSize());
4192 EXPECT_EQ(16375u, framer.GetDataFrameMaximumPayload());
4193 } else {
4194 EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
4195 EXPECT_EQ(18u, framer.GetSynStreamMinimumSize());
4196 EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize());
4197 EXPECT_EQ(16u, framer.GetRstStreamMinimumSize());
4198 EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
4199 EXPECT_EQ(12u, framer.GetPingSize());
4200 EXPECT_EQ(IsSpdy2() ? 12u : 16u, framer.GetGoAwayMinimumSize());
4201 EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetHeadersMinimumSize());
4202 EXPECT_EQ(16u, framer.GetWindowUpdateSize());
4203 EXPECT_EQ(8u, framer.GetFrameMinimumSize());
4204 EXPECT_EQ(16777223u, framer.GetFrameMaximumSize());
4205 EXPECT_EQ(16777215u, framer.GetDataFrameMaximumPayload());
4206 }
4207 }
4208
4209 TEST_P(SpdyFramerTest, StateToStringTest) {
4210 EXPECT_STREQ("ERROR",
4211 SpdyFramer::StateToString(SpdyFramer::SPDY_ERROR));
4212 EXPECT_STREQ("AUTO_RESET",
4213 SpdyFramer::StateToString(SpdyFramer::SPDY_AUTO_RESET));
4214 EXPECT_STREQ("RESET",
4215 SpdyFramer::StateToString(SpdyFramer::SPDY_RESET));
4216 EXPECT_STREQ("READING_COMMON_HEADER",
4217 SpdyFramer::StateToString(
4218 SpdyFramer::SPDY_READING_COMMON_HEADER));
4219 EXPECT_STREQ("CONTROL_FRAME_PAYLOAD",
4220 SpdyFramer::StateToString(
4221 SpdyFramer::SPDY_CONTROL_FRAME_PAYLOAD));
4222 EXPECT_STREQ("IGNORE_REMAINING_PAYLOAD",
4223 SpdyFramer::StateToString(
4224 SpdyFramer::SPDY_IGNORE_REMAINING_PAYLOAD));
4225 EXPECT_STREQ("FORWARD_STREAM_FRAME",
4226 SpdyFramer::StateToString(
4227 SpdyFramer::SPDY_FORWARD_STREAM_FRAME));
4228 EXPECT_STREQ("SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK",
4229 SpdyFramer::StateToString(
4230 SpdyFramer::SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK));
4231 EXPECT_STREQ("SPDY_CONTROL_FRAME_HEADER_BLOCK",
4232 SpdyFramer::StateToString(
4233 SpdyFramer::SPDY_CONTROL_FRAME_HEADER_BLOCK));
4234 EXPECT_STREQ("SPDY_SETTINGS_FRAME_PAYLOAD",
4235 SpdyFramer::StateToString(
4236 SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD));
4237 EXPECT_STREQ("SPDY_ALTSVC_FRAME_PAYLOAD",
4238 SpdyFramer::StateToString(
4239 SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD));
4240 EXPECT_STREQ("UNKNOWN_STATE",
4241 SpdyFramer::StateToString(
4242 SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD + 1));
4243 }
4244
4245 TEST_P(SpdyFramerTest, ErrorCodeToStringTest) {
4246 EXPECT_STREQ("NO_ERROR",
4247 SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_NO_ERROR));
4248 EXPECT_STREQ("INVALID_CONTROL_FRAME",
4249 SpdyFramer::ErrorCodeToString(
4250 SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
4251 EXPECT_STREQ("CONTROL_PAYLOAD_TOO_LARGE",
4252 SpdyFramer::ErrorCodeToString(
4253 SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE));
4254 EXPECT_STREQ("ZLIB_INIT_FAILURE",
4255 SpdyFramer::ErrorCodeToString(
4256 SpdyFramer::SPDY_ZLIB_INIT_FAILURE));
4257 EXPECT_STREQ("UNSUPPORTED_VERSION",
4258 SpdyFramer::ErrorCodeToString(
4259 SpdyFramer::SPDY_UNSUPPORTED_VERSION));
4260 EXPECT_STREQ("DECOMPRESS_FAILURE",
4261 SpdyFramer::ErrorCodeToString(
4262 SpdyFramer::SPDY_DECOMPRESS_FAILURE));
4263 EXPECT_STREQ("COMPRESS_FAILURE",
4264 SpdyFramer::ErrorCodeToString(
4265 SpdyFramer::SPDY_COMPRESS_FAILURE));
4266 EXPECT_STREQ("SPDY_INVALID_DATA_FRAME_FLAGS",
4267 SpdyFramer::ErrorCodeToString(
4268 SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS));
4269 EXPECT_STREQ("SPDY_INVALID_CONTROL_FRAME_FLAGS",
4270 SpdyFramer::ErrorCodeToString(
4271 SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS));
4272 EXPECT_STREQ("UNKNOWN_ERROR",
4273 SpdyFramer::ErrorCodeToString(SpdyFramer::LAST_ERROR));
4274 }
4275
4276 TEST_P(SpdyFramerTest, StatusCodeToStringTest) {
4277 EXPECT_STREQ("INVALID",
4278 SpdyFramer::StatusCodeToString(RST_STREAM_INVALID));
4279 EXPECT_STREQ("PROTOCOL_ERROR",
4280 SpdyFramer::StatusCodeToString(RST_STREAM_PROTOCOL_ERROR));
4281 EXPECT_STREQ("INVALID_STREAM",
4282 SpdyFramer::StatusCodeToString(RST_STREAM_INVALID_STREAM));
4283 EXPECT_STREQ("REFUSED_STREAM",
4284 SpdyFramer::StatusCodeToString(RST_STREAM_REFUSED_STREAM));
4285 EXPECT_STREQ("UNSUPPORTED_VERSION",
4286 SpdyFramer::StatusCodeToString(RST_STREAM_UNSUPPORTED_VERSION));
4287 EXPECT_STREQ("CANCEL",
4288 SpdyFramer::StatusCodeToString(RST_STREAM_CANCEL));
4289 EXPECT_STREQ("INTERNAL_ERROR",
4290 SpdyFramer::StatusCodeToString(RST_STREAM_INTERNAL_ERROR));
4291 EXPECT_STREQ("FLOW_CONTROL_ERROR",
4292 SpdyFramer::StatusCodeToString(RST_STREAM_FLOW_CONTROL_ERROR));
4293 EXPECT_STREQ("UNKNOWN_STATUS",
4294 SpdyFramer::StatusCodeToString(-1));
4295 }
4296
4297 TEST_P(SpdyFramerTest, FrameTypeToStringTest) {
4298 EXPECT_STREQ("DATA",
4299 SpdyFramer::FrameTypeToString(DATA));
4300 EXPECT_STREQ("SYN_STREAM",
4301 SpdyFramer::FrameTypeToString(SYN_STREAM));
4302 EXPECT_STREQ("SYN_REPLY",
4303 SpdyFramer::FrameTypeToString(SYN_REPLY));
4304 EXPECT_STREQ("RST_STREAM",
4305 SpdyFramer::FrameTypeToString(RST_STREAM));
4306 EXPECT_STREQ("SETTINGS",
4307 SpdyFramer::FrameTypeToString(SETTINGS));
4308 EXPECT_STREQ("NOOP",
4309 SpdyFramer::FrameTypeToString(NOOP));
4310 EXPECT_STREQ("PING",
4311 SpdyFramer::FrameTypeToString(PING));
4312 EXPECT_STREQ("GOAWAY",
4313 SpdyFramer::FrameTypeToString(GOAWAY));
4314 EXPECT_STREQ("HEADERS",
4315 SpdyFramer::FrameTypeToString(HEADERS));
4316 EXPECT_STREQ("WINDOW_UPDATE",
4317 SpdyFramer::FrameTypeToString(WINDOW_UPDATE));
4318 EXPECT_STREQ("PUSH_PROMISE",
4319 SpdyFramer::FrameTypeToString(PUSH_PROMISE));
4320 EXPECT_STREQ("CREDENTIAL",
4321 SpdyFramer::FrameTypeToString(CREDENTIAL));
4322 EXPECT_STREQ("CONTINUATION",
4323 SpdyFramer::FrameTypeToString(CONTINUATION));
4324 }
4325
4326 TEST_P(SpdyFramerTest, CatchProbableHttpResponse) {
4327 if (IsSpdy4()) {
4328 // TODO(hkhalil): catch probable HTTP response in SPDY 4?
4329 return;
4330 }
4331 {
4332 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4333 SpdyFramer framer(spdy_version_);
4334 framer.set_visitor(&visitor);
4335
4336 EXPECT_CALL(visitor, OnError(_));
4337 framer.ProcessInput("HTTP/1.1", 8);
4338 EXPECT_TRUE(framer.probable_http_response());
4339 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4340 EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
4341 << SpdyFramer::ErrorCodeToString(framer.error_code());
4342 }
4343 {
4344 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4345 SpdyFramer framer(spdy_version_);
4346 framer.set_visitor(&visitor);
4347
4348 EXPECT_CALL(visitor, OnError(_));
4349 framer.ProcessInput("HTTP/1.0", 8);
4350 EXPECT_TRUE(framer.probable_http_response());
4351 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4352 EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
4353 << SpdyFramer::ErrorCodeToString(framer.error_code());
4354 }
4355 }
4356
4357 TEST_P(SpdyFramerTest, DataFrameFlagsV2V3) {
4358 if (spdy_version_ > SPDY3) {
4359 return;
4360 }
4361
4362 for (int flags = 0; flags < 256; ++flags) {
4363 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4364
4365 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4366 SpdyFramer framer(spdy_version_);
4367 framer.set_visitor(&visitor);
4368
4369 SpdyDataIR data_ir(1, StringPiece("hello", 5));
4370 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
4371 SetFrameFlags(frame.get(), flags, spdy_version_);
4372
4373 if (flags & ~DATA_FLAG_FIN) {
4374 EXPECT_CALL(visitor, OnError(_));
4375 } else {
4376 EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
4377 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
4378 if (flags & DATA_FLAG_FIN) {
4379 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
4380 }
4381 }
4382
4383 framer.ProcessInput(frame->data(), frame->size());
4384 if (flags & ~DATA_FLAG_FIN) {
4385 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4386 EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS,
4387 framer.error_code())
4388 << SpdyFramer::ErrorCodeToString(framer.error_code());
4389 } else {
4390 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4391 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4392 << SpdyFramer::ErrorCodeToString(framer.error_code());
4393 }
4394 }
4395 }
4396
4397 TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
4398 if (spdy_version_ <= SPDY3) {
4399 return;
4400 }
4401
4402 uint8 valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_END_SEGMENT |
4403 DATA_FLAG_PAD_LOW | DATA_FLAG_PAD_HIGH;
4404
4405 for (int flags = 0; flags < 256; ++flags) {
4406 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4407
4408 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4409 SpdyFramer framer(spdy_version_);
4410 framer.set_visitor(&visitor);
4411
4412 SpdyDataIR data_ir(1, StringPiece("hello", 5));
4413 scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
4414 SetFrameFlags(frame.get(), flags, spdy_version_);
4415
4416 if (flags & ~valid_data_flags) {
4417 EXPECT_CALL(visitor, OnError(_));
4418 } else {
4419 EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
4420 if ((flags & DATA_FLAG_PAD_LOW) || (flags & DATA_FLAG_PAD_HIGH)) {
4421 // Expect Error since we don't set pad_high and pad_low in payload.
4422 EXPECT_CALL(visitor, OnError(_));
4423 } else {
4424 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
4425 if (flags & DATA_FLAG_FIN) {
4426 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
4427 }
4428 }
4429 }
4430
4431 framer.ProcessInput(frame->data(), frame->size());
4432 if ((flags & ~valid_data_flags) || (flags & DATA_FLAG_PAD_LOW) ||
4433 (flags & DATA_FLAG_PAD_HIGH)) {
4434 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4435 EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS,
4436 framer.error_code())
4437 << SpdyFramer::ErrorCodeToString(framer.error_code());
4438 } else {
4439 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4440 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4441 << SpdyFramer::ErrorCodeToString(framer.error_code());
4442 }
4443 }
4444 }
4445
4446 TEST_P(SpdyFramerTest, SynStreamFrameFlags) {
4447 for (int flags = 0; flags < 256; ++flags) {
4448 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4449
4450 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4451 testing::StrictMock<test::MockDebugVisitor> debug_visitor;
4452 SpdyFramer framer(spdy_version_);
4453 framer.set_visitor(&visitor);
4454 framer.set_debug_visitor(&debug_visitor);
4455
4456 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
4457
4458 SpdySynStreamIR syn_stream(8);
4459 syn_stream.set_associated_to_stream_id(3);
4460 syn_stream.set_priority(1);
4461 syn_stream.SetHeader("foo", "bar");
4462 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
4463 int set_flags = flags;
4464 if (IsSpdy4()) {
4465 // PRIORITY required for SYN_STREAM simulation.
4466 set_flags |= HEADERS_FLAG_PRIORITY;
4467
4468 // TODO(jgraettinger): Add padding to SynStreamIR, and implement framing.
4469 set_flags &= ~HEADERS_FLAG_PAD_LOW;
4470 set_flags &= ~HEADERS_FLAG_PAD_HIGH;
4471 }
4472 SetFrameFlags(frame.get(), set_flags, spdy_version_);
4473
4474 if (!IsSpdy4() &&
4475 flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
4476 EXPECT_CALL(visitor, OnError(_));
4477 } else if (IsSpdy4() &&
4478 flags & ~(CONTROL_FLAG_FIN |
4479 HEADERS_FLAG_PRIORITY |
4480 HEADERS_FLAG_END_HEADERS |
4481 HEADERS_FLAG_END_SEGMENT |
4482 HEADERS_FLAG_PAD_LOW |
4483 HEADERS_FLAG_PAD_HIGH)) {
4484 EXPECT_CALL(visitor, OnError(_));
4485 } else {
4486 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
4487 if (IsSpdy4()) {
4488 EXPECT_CALL(visitor, OnSynStream(8, 0, 1, flags & CONTROL_FLAG_FIN,
4489 false));
4490 } else {
4491 EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
4492 flags & CONTROL_FLAG_UNIDIRECTIONAL));
4493 }
4494 EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
4495 .WillRepeatedly(testing::Return(true));
4496 if (flags & DATA_FLAG_FIN && (!IsSpdy4() ||
4497 flags & HEADERS_FLAG_END_HEADERS)) {
4498 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
4499 } else {
4500 // Do not close the stream if we are expecting a CONTINUATION frame.
4501 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
4502 }
4503 }
4504
4505 framer.ProcessInput(frame->data(), frame->size());
4506 if (!IsSpdy4() &&
4507 flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
4508 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4509 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4510 framer.error_code())
4511 << SpdyFramer::ErrorCodeToString(framer.error_code());
4512 } else if (IsSpdy4() &&
4513 flags & ~(CONTROL_FLAG_FIN |
4514 HEADERS_FLAG_PRIORITY |
4515 HEADERS_FLAG_END_HEADERS |
4516 HEADERS_FLAG_END_SEGMENT |
4517 HEADERS_FLAG_PAD_LOW |
4518 HEADERS_FLAG_PAD_HIGH)) {
4519 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4520 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4521 framer.error_code())
4522 << SpdyFramer::ErrorCodeToString(framer.error_code());
4523 } else {
4524 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4525 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4526 << SpdyFramer::ErrorCodeToString(framer.error_code());
4527 }
4528 }
4529 }
4530
4531 TEST_P(SpdyFramerTest, SynReplyFrameFlags) {
4532 if (IsSpdy4()) {
4533 // Covered by HEADERS case.
4534 return;
4535 }
4536 for (int flags = 0; flags < 256; ++flags) {
4537 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4538
4539 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4540 SpdyFramer framer(spdy_version_);
4541 framer.set_visitor(&visitor);
4542
4543 SpdySynReplyIR syn_reply(37);
4544 syn_reply.SetHeader("foo", "bar");
4545 scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
4546 SetFrameFlags(frame.get(), flags, spdy_version_);
4547
4548 if (flags & ~CONTROL_FLAG_FIN) {
4549 EXPECT_CALL(visitor, OnError(_));
4550 } else {
4551 EXPECT_CALL(visitor, OnSynReply(37, flags & CONTROL_FLAG_FIN));
4552 EXPECT_CALL(visitor, OnControlFrameHeaderData(37, _, _))
4553 .WillRepeatedly(testing::Return(true));
4554 if (flags & DATA_FLAG_FIN) {
4555 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
4556 }
4557 }
4558
4559 framer.ProcessInput(frame->data(), frame->size());
4560 if (flags & ~CONTROL_FLAG_FIN) {
4561 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4562 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4563 framer.error_code())
4564 << SpdyFramer::ErrorCodeToString(framer.error_code());
4565 } else {
4566 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4567 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4568 << SpdyFramer::ErrorCodeToString(framer.error_code());
4569 }
4570 }
4571 }
4572
4573 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
4574 for (int flags = 0; flags < 256; ++flags) {
4575 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4576
4577 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4578 SpdyFramer framer(spdy_version_);
4579 framer.set_visitor(&visitor);
4580
4581 SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL, "");
4582 scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
4583 SetFrameFlags(frame.get(), flags, spdy_version_);
4584
4585 if (flags != 0) {
4586 EXPECT_CALL(visitor, OnError(_));
4587 } else {
4588 EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
4589 }
4590
4591 framer.ProcessInput(frame->data(), frame->size());
4592 if (flags != 0) {
4593 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4594 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4595 framer.error_code())
4596 << SpdyFramer::ErrorCodeToString(framer.error_code());
4597 } else {
4598 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4599 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4600 << SpdyFramer::ErrorCodeToString(framer.error_code());
4601 }
4602 }
4603 }
4604
4605 TEST_P(SpdyFramerTest, SettingsFrameFlagsOldFormat) {
4606 if (spdy_version_ > SPDY3) { return; }
4607 for (int flags = 0; flags < 256; ++flags) {
4608 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4609
4610 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4611 SpdyFramer framer(spdy_version_);
4612 framer.set_visitor(&visitor);
4613
4614 SpdySettingsIR settings_ir;
4615 settings_ir.AddSetting(SETTINGS_UPLOAD_BANDWIDTH,
4616 false,
4617 false,
4618 54321);
4619 scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
4620 SetFrameFlags(frame.get(), flags, spdy_version_);
4621
4622 if (flags & ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
4623 EXPECT_CALL(visitor, OnError(_));
4624 } else {
4625 EXPECT_CALL(visitor, OnSettings(
4626 flags & SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS));
4627 EXPECT_CALL(visitor, OnSetting(SETTINGS_UPLOAD_BANDWIDTH,
4628 SETTINGS_FLAG_NONE, 54321));
4629 EXPECT_CALL(visitor, OnSettingsEnd());
4630 }
4631
4632 framer.ProcessInput(frame->data(), frame->size());
4633 if (flags & ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
4634 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4635 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4636 framer.error_code())
4637 << SpdyFramer::ErrorCodeToString(framer.error_code());
4638 } else {
4639 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4640 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4641 << SpdyFramer::ErrorCodeToString(framer.error_code());
4642 }
4643 }
4644 }
4645
4646 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
4647 if (spdy_version_ <= SPDY3) { return; }
4648 for (int flags = 0; flags < 256; ++flags) {
4649 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4650
4651 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4652 SpdyFramer framer(spdy_version_);
4653 framer.set_visitor(&visitor);
4654
4655 SpdySettingsIR settings_ir;
4656 settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
4657 scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
4658 SetFrameFlags(frame.get(), flags, spdy_version_);
4659
4660 if (flags != 0) {
4661 EXPECT_CALL(visitor, OnError(_));
4662 } else {
4663 EXPECT_CALL(visitor, OnSettings(flags & SETTINGS_FLAG_ACK));
4664 EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 16));
4665 EXPECT_CALL(visitor, OnSettingsEnd());
4666 }
4667
4668 framer.ProcessInput(frame->data(), frame->size());
4669 if (flags & ~SETTINGS_FLAG_ACK) {
4670 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4671 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4672 framer.error_code())
4673 << SpdyFramer::ErrorCodeToString(framer.error_code());
4674 } else if (flags & SETTINGS_FLAG_ACK) {
4675 // The frame is invalid because ACK frames should have no payload.
4676 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4677 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
4678 framer.error_code())
4679 << SpdyFramer::ErrorCodeToString(framer.error_code());
4680 } else {
4681 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4682 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4683 << SpdyFramer::ErrorCodeToString(framer.error_code());
4684 }
4685 }
4686 }
4687
4688 TEST_P(SpdyFramerTest, GoawayFrameFlags) {
4689 for (int flags = 0; flags < 256; ++flags) {
4690 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4691
4692 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4693 SpdyFramer framer(spdy_version_);
4694 framer.set_visitor(&visitor);
4695
4696 SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
4697 scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
4698 SetFrameFlags(frame.get(), flags, spdy_version_);
4699
4700 if (flags != 0) {
4701 EXPECT_CALL(visitor, OnError(_));
4702 } else {
4703 EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_OK));
4704 }
4705
4706 framer.ProcessInput(frame->data(), frame->size());
4707 if (flags != 0) {
4708 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4709 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4710 framer.error_code())
4711 << SpdyFramer::ErrorCodeToString(framer.error_code());
4712 } else {
4713 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4714 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4715 << SpdyFramer::ErrorCodeToString(framer.error_code());
4716 }
4717 }
4718 }
4719
4720 TEST_P(SpdyFramerTest, HeadersFrameFlags) {
4721 for (int flags = 0; flags < 256; ++flags) {
4722 if (IsSpdy4() && flags & HEADERS_FLAG_PRIORITY) {
4723 // Covered by SYN_STREAM case.
4724 continue;
4725 }
4726 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4727
4728 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4729 SpdyFramer framer(spdy_version_);
4730 framer.set_visitor(&visitor);
4731
4732 SpdyHeadersIR headers_ir(57);
4733 headers_ir.SetHeader("foo", "bar");
4734 scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
4735 int set_flags = flags;
4736 if (IsSpdy4()) {
4737 // TODO(jgraettinger): Add padding to SpdyHeadersIR,
4738 // and implement framing.
4739 set_flags &= ~HEADERS_FLAG_PAD_LOW;
4740 set_flags &= ~HEADERS_FLAG_PAD_HIGH;
4741 }
4742 SetFrameFlags(frame.get(), set_flags, spdy_version_);
4743
4744 if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
4745 EXPECT_CALL(visitor, OnError(_));
4746 } else if (IsSpdy4() && flags & ~(CONTROL_FLAG_FIN |
4747 HEADERS_FLAG_END_HEADERS |
4748 HEADERS_FLAG_END_SEGMENT |
4749 HEADERS_FLAG_PAD_LOW |
4750 HEADERS_FLAG_PAD_HIGH)) {
4751 EXPECT_CALL(visitor, OnError(_));
4752 } else {
4753 EXPECT_CALL(visitor, OnHeaders(57,
4754 flags & CONTROL_FLAG_FIN,
4755 (flags & HEADERS_FLAG_END_HEADERS) ||
4756 !IsSpdy4()));
4757 EXPECT_CALL(visitor, OnControlFrameHeaderData(57, _, _))
4758 .WillRepeatedly(testing::Return(true));
4759 if (flags & DATA_FLAG_FIN && (!IsSpdy4() ||
4760 flags & HEADERS_FLAG_END_HEADERS)) {
4761 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
4762 } else {
4763 // Do not close the stream if we are expecting a CONTINUATION frame.
4764 EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
4765 }
4766 }
4767
4768 framer.ProcessInput(frame->data(), frame->size());
4769 if (!IsSpdy4() && flags & ~CONTROL_FLAG_FIN) {
4770 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4771 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4772 framer.error_code())
4773 << SpdyFramer::ErrorCodeToString(framer.error_code());
4774 } else if (IsSpdy4() && flags & ~(CONTROL_FLAG_FIN |
4775 HEADERS_FLAG_END_HEADERS |
4776 HEADERS_FLAG_END_SEGMENT |
4777 HEADERS_FLAG_PAD_LOW |
4778 HEADERS_FLAG_PAD_HIGH)) {
4779 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4780 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4781 framer.error_code())
4782 << SpdyFramer::ErrorCodeToString(framer.error_code());
4783 } else if (IsSpdy4() && ~(flags & HEADERS_FLAG_END_HEADERS)) {
4784 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4785 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4786 << SpdyFramer::ErrorCodeToString(framer.error_code());
4787 } else {
4788 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4789 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4790 << SpdyFramer::ErrorCodeToString(framer.error_code());
4791 }
4792 }
4793 }
4794
4795 TEST_P(SpdyFramerTest, PingFrameFlags) {
4796 for (int flags = 0; flags < 256; ++flags) {
4797 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4798
4799 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4800 SpdyFramer framer(spdy_version_);
4801 framer.set_visitor(&visitor);
4802
4803 scoped_ptr<SpdyFrame> frame(framer.SerializePing(SpdyPingIR(42)));
4804 SetFrameFlags(frame.get(), flags, spdy_version_);
4805
4806 if (spdy_version_ > SPDY3 &&
4807 flags == PING_FLAG_ACK) {
4808 EXPECT_CALL(visitor, OnPing(42, true));
4809 } else if (flags == 0) {
4810 EXPECT_CALL(visitor, OnPing(42, false));
4811 } else {
4812 EXPECT_CALL(visitor, OnError(_));
4813 }
4814
4815 framer.ProcessInput(frame->data(), frame->size());
4816 if ((spdy_version_ > SPDY3 && flags == PING_FLAG_ACK) ||
4817 flags == 0) {
4818 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4819 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4820 << SpdyFramer::ErrorCodeToString(framer.error_code());
4821 } else {
4822 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4823 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4824 framer.error_code())
4825 << SpdyFramer::ErrorCodeToString(framer.error_code());
4826 }
4827 }
4828 }
4829
4830 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
4831 for (int flags = 0; flags < 256; ++flags) {
4832 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4833
4834 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4835 SpdyFramer framer(spdy_version_);
4836 framer.set_visitor(&visitor);
4837
4838 scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
4839 SpdyWindowUpdateIR(4, 1024)));
4840 SetFrameFlags(frame.get(), flags, spdy_version_);
4841
4842 if (flags != 0) {
4843 EXPECT_CALL(visitor, OnError(_));
4844 } else {
4845 EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
4846 }
4847
4848 framer.ProcessInput(frame->data(), frame->size());
4849 if (flags != 0) {
4850 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4851 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4852 framer.error_code())
4853 << SpdyFramer::ErrorCodeToString(framer.error_code());
4854 } else {
4855 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4856 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4857 << SpdyFramer::ErrorCodeToString(framer.error_code());
4858 }
4859 }
4860 }
4861
4862 TEST_P(SpdyFramerTest, PushPromiseFrameFlags) {
4863 if (spdy_version_ <= SPDY3) {
4864 return;
4865 }
4866
4867 for (int flags = 0; flags < 256; ++flags) {
4868 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4869
4870 testing::StrictMock<net::test::MockSpdyFramerVisitor> visitor;
4871 testing::StrictMock<net::test::MockDebugVisitor> debug_visitor;
4872 SpdyFramer framer(spdy_version_);
4873 framer.set_visitor(&visitor);
4874 framer.set_debug_visitor(&debug_visitor);
4875
4876 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, PUSH_PROMISE, _, _));
4877
4878 SpdyPushPromiseIR push_promise(42, 57);
4879 push_promise.SetHeader("foo", "bar");
4880 scoped_ptr<SpdySerializedFrame> frame(
4881 framer.SerializePushPromise(push_promise));
4882 // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
4883 // and implement framing.
4884 int set_flags = flags & ~HEADERS_FLAG_PAD_LOW & ~HEADERS_FLAG_PAD_HIGH;
4885 SetFrameFlags(frame.get(), set_flags, spdy_version_);
4886
4887 if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
4888 HEADERS_FLAG_PAD_LOW |
4889 HEADERS_FLAG_PAD_HIGH)) {
4890 EXPECT_CALL(visitor, OnError(_));
4891 } else {
4892 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, PUSH_PROMISE, _));
4893 EXPECT_CALL(visitor, OnPushPromise(42, 57,
4894 flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE));
4895 EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
4896 .WillRepeatedly(testing::Return(true));
4897 }
4898
4899 framer.ProcessInput(frame->data(), frame->size());
4900 if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE |
4901 HEADERS_FLAG_PAD_LOW |
4902 HEADERS_FLAG_PAD_HIGH)) {
4903 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4904 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4905 framer.error_code())
4906 << SpdyFramer::ErrorCodeToString(framer.error_code());
4907 } else {
4908 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4909 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4910 << SpdyFramer::ErrorCodeToString(framer.error_code());
4911 }
4912 }
4913 }
4914
4915 TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
4916 if (spdy_version_ <= SPDY3) {
4917 return;
4918 }
4919
4920 for (int flags = 0; flags < 256; ++flags) {
4921 SCOPED_TRACE(testing::Message() << "Flags " << flags);
4922
4923 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4924 testing::StrictMock<net::test::MockDebugVisitor> debug_visitor;
4925 SpdyFramer framer(spdy_version_);
4926 framer.set_visitor(&visitor);
4927 framer.set_debug_visitor(&debug_visitor);
4928
4929 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
4930 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _));
4931 EXPECT_CALL(visitor, OnHeaders(42, 0, false));
4932 EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
4933 .WillRepeatedly(testing::Return(true));
4934 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, CONTINUATION, _, _));
4935
4936 SpdyHeadersIR headers_ir(42);
4937 headers_ir.SetHeader("foo", "bar");
4938 scoped_ptr<SpdyFrame> frame0(framer.SerializeHeaders(headers_ir));
4939 SetFrameFlags(frame0.get(), 0, spdy_version_);
4940
4941 SpdyContinuationIR continuation(42);
4942 continuation.SetHeader("foo", "bar");
4943 scoped_ptr<SpdySerializedFrame> frame(
4944 framer.SerializeContinuation(continuation));
4945 // TODO(jgraettinger): Add padding to the eventual continuation
4946 // serialization implementation.
4947 int set_flags = flags & ~HEADERS_FLAG_PAD_LOW & ~HEADERS_FLAG_PAD_HIGH;
4948 SetFrameFlags(frame.get(), set_flags, spdy_version_);
4949
4950 if (flags & ~(HEADERS_FLAG_END_HEADERS |
4951 HEADERS_FLAG_PAD_LOW |
4952 HEADERS_FLAG_PAD_HIGH)) {
4953 EXPECT_CALL(visitor, OnError(_));
4954 } else {
4955 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _));
4956 EXPECT_CALL(visitor, OnContinuation(42,
4957 flags & HEADERS_FLAG_END_HEADERS));
4958 EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
4959 .WillRepeatedly(testing::Return(true));
4960 }
4961
4962 framer.ProcessInput(frame0->data(), frame0->size());
4963 framer.ProcessInput(frame->data(), frame->size());
4964 if (flags & ~(HEADERS_FLAG_END_HEADERS |
4965 HEADERS_FLAG_PAD_LOW |
4966 HEADERS_FLAG_PAD_HIGH)) {
4967 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
4968 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
4969 framer.error_code())
4970 << SpdyFramer::ErrorCodeToString(framer.error_code());
4971 } else {
4972 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
4973 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
4974 << SpdyFramer::ErrorCodeToString(framer.error_code());
4975 }
4976 }
4977 }
4978
4979 // TODO(mlavan): Add TEST_P(SpdyFramerTest, AltSvcFrameFlags)
4980
4981 // TODO(hkhalil): Add TEST_P(SpdyFramerTest, BlockedFrameFlags)
4982
4983 TEST_P(SpdyFramerTest, EmptySynStream) {
4984 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
4985 testing::StrictMock<test::MockDebugVisitor> debug_visitor;
4986 SpdyFramer framer(spdy_version_);
4987 framer.set_visitor(&visitor);
4988 framer.set_debug_visitor(&debug_visitor);
4989
4990 EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
4991
4992 SpdySynStreamIR syn_stream(1);
4993 syn_stream.set_priority(1);
4994 scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
4995 // Adjust size to remove the name/value block.
4996 SetFrameLength(
4997 frame.get(),
4998 framer.GetSynStreamMinimumSize() - framer.GetControlFrameHeaderSize(),
4999 spdy_version_);
5000
5001 EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(1, SYN_STREAM, _));
5002 EXPECT_CALL(visitor, OnSynStream(1, 0, 1, false, false));
5003 EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
5004
5005 framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
5006 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5007 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5008 << SpdyFramer::ErrorCodeToString(framer.error_code());
5009 }
5010
5011 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
5012 const uint32 kId = 0x020304;
5013 const uint32 kFlags = 0x01;
5014 const uint32 kWireFormat = htonl(IsSpdy2() ? 0x04030201 : 0x01020304);
5015
5016 SettingsFlagsAndId id_and_flags =
5017 SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
5018 EXPECT_EQ(kId, id_and_flags.id());
5019 EXPECT_EQ(kFlags, id_and_flags.flags());
5020 EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
5021 }
5022
5023 // Test handling of a RST_STREAM with out-of-bounds status codes.
5024 TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
5025 const unsigned char kRstStreamStatusTooLow = 0x00;
5026 const unsigned char kRstStreamStatusTooHigh = 0xff;
5027 const unsigned char kV3RstStreamInvalid[] = {
5028 0x80, spdy_version_ch_, 0x00, 0x03,
5029 0x00, 0x00, 0x00, 0x08,
5030 0x00, 0x00, 0x00, 0x01,
5031 0x00, 0x00, 0x00, kRstStreamStatusTooLow
5032 };
5033 const unsigned char kV4RstStreamInvalid[] = {
5034 0x00, 0x04, 0x03, 0x00,
5035 0x00, 0x00, 0x00, 0x01,
5036 0x00, 0x00, 0x00, kRstStreamStatusTooLow
5037 };
5038
5039 const unsigned char kV3RstStreamNumStatusCodes[] = {
5040 0x80, spdy_version_ch_, 0x00, 0x03,
5041 0x00, 0x00, 0x00, 0x08,
5042 0x00, 0x00, 0x00, 0x01,
5043 0x00, 0x00, 0x00, kRstStreamStatusTooHigh
5044 };
5045 const unsigned char kV4RstStreamNumStatusCodes[] = {
5046 0x00, 0x04, 0x03, 0x00,
5047 0x00, 0x00, 0x00, 0x01,
5048 0x00, 0x00, 0x00, kRstStreamStatusTooHigh
5049 };
5050
5051 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
5052 SpdyFramer framer(spdy_version_);
5053 framer.set_visitor(&visitor);
5054
5055 if (IsSpdy4()) {
5056 EXPECT_CALL(visitor, OnError(_));
5057 framer.ProcessInput(reinterpret_cast<const char*>(kV4RstStreamInvalid),
5058 arraysize(kV4RstStreamInvalid));
5059 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
5060 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
5061 << SpdyFramer::ErrorCodeToString(framer.error_code());
5062 } else {
5063 EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
5064 framer.ProcessInput(reinterpret_cast<const char*>(kV3RstStreamInvalid),
5065 arraysize(kV3RstStreamInvalid));
5066 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5067 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5068 << SpdyFramer::ErrorCodeToString(framer.error_code());
5069 }
5070
5071
5072 framer.Reset();
5073
5074 if (IsSpdy4()) {
5075 EXPECT_CALL(visitor, OnError(_));
5076 framer.ProcessInput(
5077 reinterpret_cast<const char*>(kV4RstStreamNumStatusCodes),
5078 arraysize(kV4RstStreamNumStatusCodes));
5079 EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
5080 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
5081 << SpdyFramer::ErrorCodeToString(framer.error_code());
5082 } else {
5083 EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INVALID));
5084 framer.ProcessInput(
5085 reinterpret_cast<const char*>(kV3RstStreamNumStatusCodes),
5086 arraysize(kV3RstStreamNumStatusCodes));
5087 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5088 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5089 << SpdyFramer::ErrorCodeToString(framer.error_code());
5090 }
5091 }
5092
5093 // Tests handling of a GOAWAY frame with out-of-bounds stream ID.
5094 TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
5095 const unsigned char kV2FrameData[] = {
5096 0x80, spdy_version_ch_, 0x00, 0x07,
5097 0x00, 0x00, 0x00, 0x04,
5098 0xff, 0xff, 0xff, 0xff,
5099 };
5100 const unsigned char kV3FrameData[] = {
5101 0x80, spdy_version_ch_, 0x00, 0x07,
5102 0x00, 0x00, 0x00, 0x08,
5103 0xff, 0xff, 0xff, 0xff,
5104 0x00, 0x00, 0x00, 0x00,
5105 };
5106 const unsigned char kV4FrameData[] = {
5107 0x00, 0x08, 0x07, 0x00,
5108 0x00, 0x00, 0x00, 0x00,
5109 0xff, 0xff, 0xff, 0xff,
5110 0x00, 0x00, 0x00, 0x00,
5111 };
5112
5113 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
5114 SpdyFramer framer(spdy_version_);
5115 framer.set_visitor(&visitor);
5116
5117 EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
5118 if (IsSpdy2()) {
5119 framer.ProcessInput(reinterpret_cast<const char*>(kV2FrameData),
5120 arraysize(kV2FrameData));
5121 } else if (IsSpdy3()) {
5122 framer.ProcessInput(reinterpret_cast<const char*>(kV3FrameData),
5123 arraysize(kV3FrameData));
5124 } else {
5125 framer.ProcessInput(reinterpret_cast<const char*>(kV4FrameData),
5126 arraysize(kV4FrameData));
5127 }
5128 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5129 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5130 << SpdyFramer::ErrorCodeToString(framer.error_code());
5131 }
5132
5133 TEST_P(SpdyFramerTest, OnBlocked) {
5134 if (spdy_version_ <= SPDY3) {
5135 return;
5136 }
5137
5138 const SpdyStreamId kStreamId = 0;
5139
5140 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
5141 SpdyFramer framer(spdy_version_);
5142 framer.set_visitor(&visitor);
5143
5144 EXPECT_CALL(visitor, OnBlocked(kStreamId));
5145
5146 SpdyBlockedIR blocked_ir(0);
5147 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
5148 framer.ProcessInput(frame->data(), framer.GetBlockedSize());
5149
5150 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5151 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5152 << SpdyFramer::ErrorCodeToString(framer.error_code());
5153 }
5154
5155 TEST_P(SpdyFramerTest, OnAltSvc) {
5156 if (spdy_version_ <= SPDY3) {
5157 return;
5158 }
5159
5160 const SpdyStreamId kStreamId = 1;
5161
5162 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
5163 SpdyFramer framer(spdy_version_);
5164 framer.set_visitor(&visitor);
5165
5166 EXPECT_CALL(visitor, OnAltSvc(kStreamId,
5167 10,
5168 443,
5169 StringPiece("pid"),
5170 StringPiece("h1"),
5171 StringPiece("o1")));
5172
5173 SpdyAltSvcIR altsvc_ir(1);
5174 altsvc_ir.set_max_age(10);
5175 altsvc_ir.set_port(443);
5176 altsvc_ir.set_protocol_id("pid");
5177 altsvc_ir.set_host("h1");
5178 altsvc_ir.set_origin("o1");
5179 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
5180 framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
5181 altsvc_ir.protocol_id().length() +
5182 altsvc_ir.host().length() +
5183 altsvc_ir.origin().length());
5184
5185 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5186 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5187 << SpdyFramer::ErrorCodeToString(framer.error_code());
5188 }
5189
5190 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
5191 if (spdy_version_ <= SPDY3) {
5192 return;
5193 }
5194
5195 const SpdyStreamId kStreamId = 1;
5196
5197 testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
5198 SpdyFramer framer(spdy_version_);
5199 framer.set_visitor(&visitor);
5200
5201 EXPECT_CALL(visitor, OnAltSvc(kStreamId,
5202 10,
5203 443,
5204 StringPiece("pid"),
5205 StringPiece("h1"),
5206 StringPiece("")));
5207
5208 SpdyAltSvcIR altsvc_ir(1);
5209 altsvc_ir.set_max_age(10);
5210 altsvc_ir.set_port(443);
5211 altsvc_ir.set_protocol_id("pid");
5212 altsvc_ir.set_host("h1");
5213 scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
5214 framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
5215 altsvc_ir.protocol_id().length() +
5216 altsvc_ir.host().length());
5217
5218 EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
5219 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
5220 << SpdyFramer::ErrorCodeToString(framer.error_code());
5221 }
5222
5223 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
5224 if (spdy_version_ <= SPDY3) {
5225 return;
5226 }
5227
5228 const unsigned char kType = static_cast<unsigned char>(
5229 SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
5230 {
5231 TestSpdyVisitor visitor(spdy_version_);
5232 SpdyFramer framer(spdy_version_);
5233 framer.set_visitor(&visitor);
5234
5235 const unsigned char kFrameDataLargePIDLen[] = {
5236 0x00, 0x17, kType, 0x00,
5237 0x00, 0x00, 0x00, 0x03,
5238 0x00, 0x00, 0x00, 0x05,
5239 0x01, 0xbb, 0x00, 0x05, // Port = 443
5240 'p', 'i', 'd', '1', // Protocol-ID
5241 0x04, 'h', 'o', 's',
5242 't', 'o', 'r', 'i',
5243 'g', 'i', 'n',
5244 };
5245
5246 visitor.SimulateInFramer(kFrameDataLargePIDLen,
5247 sizeof(kFrameDataLargePIDLen));
5248 EXPECT_EQ(1, visitor.error_count_);
5249 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
5250 visitor.framer_.error_code());
5251 }
5252
5253 {
5254 TestSpdyVisitor visitor(spdy_version_);
5255 SpdyFramer framer(spdy_version_);
5256 framer.set_visitor(&visitor);
5257 const unsigned char kFrameDataPIDLenLargerThanFrame[] = {
5258 0x00, 0x17, kType, 0x00,
5259 0x00, 0x00, 0x00, 0x03,
5260 0x00, 0x00, 0x00, 0x05,
5261 0x01, 0xbb, 0x00, 0x99, // Port = 443
5262 'p', 'i', 'd', '1', // Protocol-ID
5263 0x04, 'h', 'o', 's',
5264 't', 'o', 'r', 'i',
5265 'g', 'i', 'n',
5266 };
5267
5268 visitor.SimulateInFramer(kFrameDataPIDLenLargerThanFrame,
5269 sizeof(kFrameDataPIDLenLargerThanFrame));
5270 EXPECT_EQ(1, visitor.error_count_);
5271 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
5272 visitor.framer_.error_code());
5273 }
5274
5275 {
5276 TestSpdyVisitor visitor(spdy_version_);
5277 SpdyFramer framer(spdy_version_);
5278 framer.set_visitor(&visitor);
5279
5280 const unsigned char kFrameDataLargeHostLen[] = {
5281 0x00, 0x17, kType, 0x00,
5282 0x00, 0x00, 0x00, 0x03,
5283 0x00, 0x00, 0x00, 0x05,
5284 0x01, 0xbb, 0x00, 0x04, // Port = 443
5285 'p', 'i', 'd', '1', // Protocol-ID
5286 0x0f, 'h', 'o', 's',
5287 't', 'o', 'r', 'i',
5288 'g', 'i', 'n',
5289 };
5290
5291 visitor.SimulateInFramer(kFrameDataLargeHostLen,
5292 sizeof(kFrameDataLargeHostLen));
5293 EXPECT_EQ(1, visitor.error_count_);
5294 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
5295 visitor.framer_.error_code());
5296 }
5297
5298 {
5299 TestSpdyVisitor visitor(spdy_version_);
5300 SpdyFramer framer(spdy_version_);
5301 framer.set_visitor(&visitor);
5302 const unsigned char kFrameDataSmallPIDLen[] = {
5303 0x00, 0x17, kType, 0x00,
5304 0x00, 0x00, 0x00, 0x03,
5305 0x00, 0x00, 0x00, 0x05,
5306 0x01, 0xbb, 0x00, 0x01, // Port = 443
5307 'p', 'i', 'd', '1', // Protocol-ID
5308 0x04, 'h', 'o', 's',
5309 't', 'o', 'r', 'i',
5310 'g', 'i', 'n',
5311 };
5312
5313 visitor.SimulateInFramer(kFrameDataSmallPIDLen,
5314 sizeof(kFrameDataSmallPIDLen));
5315 EXPECT_EQ(1, visitor.error_count_);
5316 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
5317 visitor.framer_.error_code());
5318 }
5319 }
5320
5321 // Tests handling of ALTSVC frames delivered in small chunks.
5322 TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
5323 if (spdy_version_ <= SPDY3) {
5324 return;
5325 }
5326 SpdyFramer framer(spdy_version_);
5327 SpdyAltSvcIR altsvc_ir(1);
5328 altsvc_ir.set_max_age(20);
5329 altsvc_ir.set_port(443);
5330 altsvc_ir.set_protocol_id("protocolid");
5331 altsvc_ir.set_host("hostname");
5332
5333 scoped_ptr<SpdyFrame> control_frame(framer.SerializeAltSvc(altsvc_ir));
5334 TestSpdyVisitor visitor(spdy_version_);
5335 visitor.use_compression_ = false;
5336
5337 // Read data in small chunks.
5338 size_t framed_data = 0;
5339 size_t unframed_data = control_frame->size();
5340 size_t kReadChunkSize = 5; // Read five bytes at a time.
5341 while (unframed_data > 0) {
5342 size_t to_read = min(kReadChunkSize, unframed_data);
5343 visitor.SimulateInFramer(
5344 reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
5345 to_read);
5346 unframed_data -= to_read;
5347 framed_data += to_read;
5348 }
5349 EXPECT_EQ(0, visitor.error_count_);
5350 EXPECT_EQ(1, visitor.altsvc_count_);
5351 EXPECT_EQ(20u, visitor.test_altsvc_ir_.max_age());
5352 EXPECT_EQ(443u, visitor.test_altsvc_ir_.port());
5353 EXPECT_EQ("protocolid", visitor.test_altsvc_ir_.protocol_id());
5354 EXPECT_EQ("hostname", visitor.test_altsvc_ir_.host());
5355 }
5356
5357 // Tests handling of PRIORITY frames.
5358 TEST_P(SpdyFramerTest, ReadPriority) {
5359 if (spdy_version_ <= SPDY3) {
5360 return;
5361 }
5362
5363 const unsigned char kFrameData[] = {
5364 0x00, 0x05, 0x02, 0x00, // PRIORITY frame
5365 0x00, 0x00, 0x00, 0x03, // stream ID 3
5366 0x00, 0x00, 0x00, 0x01, // dependent on stream id 1
5367 0x00 // weight 0
5368 };
5369
5370 TestSpdyVisitor visitor(spdy_version_);
5371 visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
5372
5373 EXPECT_EQ(SpdyFramer::SPDY_RESET, visitor.framer_.state());
5374 EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, visitor.framer_.error_code())
5375 << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
5376 }
5377
5378 // Tests handling of PRIORITY frame with incorrect size.
5379 TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
5380 if (spdy_version_ <= SPDY3) {
5381 return;
5382 }
5383
5384 // PRIORITY frame of size 4, which isn't correct.
5385 const unsigned char kFrameData[] = {
5386 0x00, 0x04, 0x02, 0x00,
5387 0x00, 0x00, 0x00, 0x03,
5388 0x00, 0x00, 0x00, 0x01,
5389 };
5390
5391 TestSpdyVisitor visitor(spdy_version_);
5392 visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
5393
5394 EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
5395 EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
5396 visitor.framer_.error_code())
5397 << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
5398 }
5399
5400 TEST_P(SpdyFramerTest, PriorityWeightMapping) {
5401 if (spdy_version_ <= SPDY3) {
5402 return;
5403 }
5404 SpdyFramer framer(spdy_version_);
5405
5406 EXPECT_EQ(255u, framer.MapPriorityToWeight(0));
5407 EXPECT_EQ(219u, framer.MapPriorityToWeight(1));
5408 EXPECT_EQ(182u, framer.MapPriorityToWeight(2));
5409 EXPECT_EQ(146u, framer.MapPriorityToWeight(3));
5410 EXPECT_EQ(109u, framer.MapPriorityToWeight(4));
5411 EXPECT_EQ(73u, framer.MapPriorityToWeight(5));
5412 EXPECT_EQ(36u, framer.MapPriorityToWeight(6));
5413 EXPECT_EQ(0u, framer.MapPriorityToWeight(7));
5414
5415 EXPECT_EQ(0u, framer.MapWeightToPriority(255));
5416 EXPECT_EQ(0u, framer.MapWeightToPriority(220));
5417 EXPECT_EQ(1u, framer.MapWeightToPriority(219));
5418 EXPECT_EQ(1u, framer.MapWeightToPriority(183));
5419 EXPECT_EQ(2u, framer.MapWeightToPriority(182));
5420 EXPECT_EQ(2u, framer.MapWeightToPriority(147));
5421 EXPECT_EQ(3u, framer.MapWeightToPriority(146));
5422 EXPECT_EQ(3u, framer.MapWeightToPriority(110));
5423 EXPECT_EQ(4u, framer.MapWeightToPriority(109));
5424 EXPECT_EQ(4u, framer.MapWeightToPriority(74));
5425 EXPECT_EQ(5u, framer.MapWeightToPriority(73));
5426 EXPECT_EQ(5u, framer.MapWeightToPriority(37));
5427 EXPECT_EQ(6u, framer.MapWeightToPriority(36));
5428 EXPECT_EQ(6u, framer.MapWeightToPriority(1));
5429 EXPECT_EQ(7u, framer.MapWeightToPriority(0));
5430 }
5431
5432 } // namespace net