net/spdy/spdy_protocol.cc - Issue 992733002: Remove //net (except for Android test stuff) and sdch

Side by Side Diff: net/spdy/spdy_protocol.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
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 "net/spdy/spdy_protocol.h"

6

7 namespace net {

8

9 SpdyFrameWithNameValueBlockIR::SpdyFrameWithNameValueBlockIR(

10 SpdyStreamId stream_id) : SpdyFrameWithFinIR(stream_id) {}

11

12 SpdyFrameWithNameValueBlockIR::~SpdyFrameWithNameValueBlockIR() {}

13

14 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data)

15 : SpdyFrameWithFinIR(stream_id),

16 padded_(false),

17 padding_payload_len_(0) {

18 SetDataDeep(data);

19 }

20

21 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id)

22 : SpdyFrameWithFinIR(stream_id),

23 padded_(false),

24 padding_payload_len_(0) {}

25

26 SpdyDataIR::~SpdyDataIR() {}

27

28 bool SpdyConstants::IsValidFrameType(SpdyMajorVersion version,

29 int frame_type_field) {

30 switch (version) {

31 case SPDY2:

32 case SPDY3:

33 // SYN_STREAM is the first valid frame.

34 if (frame_type_field < SerializeFrameType(version, SYN_STREAM)) {

35 return false;

36 }

37

38 // WINDOW_UPDATE is the last valid frame.

39 if (frame_type_field > SerializeFrameType(version, WINDOW_UPDATE)) {

40 return false;

41 }

42

43 return true;

44 case SPDY4:

45 // Check for recognized extensions.

46 if (frame_type_field == SerializeFrameType(version, ALTSVC) \|\|

47 frame_type_field == SerializeFrameType(version, BLOCKED)) {

48 return true;

49 }

50

51 // DATA is the first valid frame.

52 if (frame_type_field < SerializeFrameType(version, DATA)) {

53 return false;

54 }

55

56 // CONTINUATION is the last valid frame.

57 if (frame_type_field > SerializeFrameType(version, CONTINUATION)) {

58 return false;

59 }

60

61 return true;

62 }

63

64 LOG(DFATAL) << "Unhandled SPDY version " << version;

65 return false;

66 }

67

68 SpdyFrameType SpdyConstants::ParseFrameType(SpdyMajorVersion version,

69 int frame_type_field) {

70 switch (version) {

71 case SPDY2:

72 case SPDY3:

73 switch (frame_type_field) {

74 case 1:

75 return SYN_STREAM;

76 case 2:

77 return SYN_REPLY;

78 case 3:

79 return RST_STREAM;

80 case 4:

81 return SETTINGS;

82 case 6:

83 return PING;

84 case 7:

85 return GOAWAY;

86 case 8:

87 return HEADERS;

88 case 9:

89 return WINDOW_UPDATE;

90 }

91 break;

92 case SPDY4:

93 switch (frame_type_field) {

94 case 0:

95 return DATA;

96 case 1:

97 return HEADERS;

98 case 2:

99 return PRIORITY;

100 case 3:

101 return RST_STREAM;

102 case 4:

103 return SETTINGS;

104 case 5:

105 return PUSH_PROMISE;

106 case 6:

107 return PING;

108 case 7:

109 return GOAWAY;

110 case 8:

111 return WINDOW_UPDATE;

112 case 9:

113 return CONTINUATION;

114 case 10:

115 return ALTSVC;

116 case 11:

117 return BLOCKED;

118 }

119 break;

120 }

121

122 LOG(DFATAL) << "Unhandled frame type " << frame_type_field;

123 return DATA;

124 }

125

126 int SpdyConstants::SerializeFrameType(SpdyMajorVersion version,

127 SpdyFrameType frame_type) {

128 switch (version) {

129 case SPDY2:

130 case SPDY3:

131 switch (frame_type) {

132 case SYN_STREAM:

133 return 1;

134 case SYN_REPLY:

135 return 2;

136 case RST_STREAM:

137 return 3;

138 case SETTINGS:

139 return 4;

140 case PING:

141 return 6;

142 case GOAWAY:

143 return 7;

144 case HEADERS:

145 return 8;

146 case WINDOW_UPDATE:

147 return 9;

148 default:

149 LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;

150 return -1;

151 }

152 case SPDY4:

153 switch (frame_type) {

154 case DATA:

155 return 0;

156 case HEADERS:

157 return 1;

158 case PRIORITY:

159 return 2;

160 case RST_STREAM:

161 return 3;

162 case SETTINGS:

163 return 4;

164 case PUSH_PROMISE:

165 return 5;

166 case PING:

167 return 6;

168 case GOAWAY:

169 return 7;

170 case WINDOW_UPDATE:

171 return 8;

172 case CONTINUATION:

173 return 9;

174 // ALTSVC and BLOCKED are extensions.

175 case ALTSVC:

176 return 10;

177 case BLOCKED:

178 return 11;

179 default:

180 LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;

181 return -1;

182 }

183 }

184

185 LOG(DFATAL) << "Unhandled SPDY version " << version;

186 return -1;

187 }

188

189 int SpdyConstants::DataFrameType(SpdyMajorVersion version) {

190 switch (version) {

191 case SPDY2:

192 case SPDY3:

193 return 0;

194 case SPDY4:

195 return SerializeFrameType(version, DATA);

196 }

197

198 LOG(DFATAL) << "Unhandled SPDY version " << version;

199 return 0;

200 }

201

202 bool SpdyConstants::IsValidSettingId(SpdyMajorVersion version,

203 int setting_id_field) {

204 switch (version) {

205 case SPDY2:

206 case SPDY3:

207 // UPLOAD_BANDWIDTH is the first valid setting id.

208 if (setting_id_field <

209 SerializeSettingId(version, SETTINGS_UPLOAD_BANDWIDTH)) {

210 return false;

211 }

212

213 // INITIAL_WINDOW_SIZE is the last valid setting id.

214 if (setting_id_field >

215 SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_SIZE)) {

216 return false;

217 }

218

219 return true;

220 case SPDY4:

221 // HEADER_TABLE_SIZE is the first valid setting id.

222 if (setting_id_field <

223 SerializeSettingId(version, SETTINGS_HEADER_TABLE_SIZE)) {

224 return false;

225 }

226

227 // MAX_HEADER_LIST_SIZE is the last valid setting id.

228 if (setting_id_field >

229 SerializeSettingId(version, SETTINGS_MAX_HEADER_LIST_SIZE)) {

230 return false;

231 }

232

233 return true;

234 }

235

236 LOG(DFATAL) << "Unhandled SPDY version " << version;

237 return false;

238 }

239

240 SpdySettingsIds SpdyConstants::ParseSettingId(SpdyMajorVersion version,

241 int setting_id_field) {

242 switch (version) {

243 case SPDY2:

244 case SPDY3:

245 switch (setting_id_field) {

246 case 1:

247 return SETTINGS_UPLOAD_BANDWIDTH;

248 case 2:

249 return SETTINGS_DOWNLOAD_BANDWIDTH;

250 case 3:

251 return SETTINGS_ROUND_TRIP_TIME;

252 case 4:

253 return SETTINGS_MAX_CONCURRENT_STREAMS;

254 case 5:

255 return SETTINGS_CURRENT_CWND;

256 case 6:

257 return SETTINGS_DOWNLOAD_RETRANS_RATE;

258 case 7:

259 return SETTINGS_INITIAL_WINDOW_SIZE;

260 }

261 break;

262 case SPDY4:

263 switch (setting_id_field) {

264 case 1:

265 return SETTINGS_HEADER_TABLE_SIZE;

266 case 2:

267 return SETTINGS_ENABLE_PUSH;

268 case 3:

269 return SETTINGS_MAX_CONCURRENT_STREAMS;

270 case 4:

271 return SETTINGS_INITIAL_WINDOW_SIZE;

272 case 5:

273 return SETTINGS_MAX_FRAME_SIZE;

274 case 6:

275 return SETTINGS_MAX_HEADER_LIST_SIZE;

276 }

277 break;

278 }

279

280 LOG(DFATAL) << "Unhandled setting ID " << setting_id_field;

281 return SETTINGS_UPLOAD_BANDWIDTH;

282 }

283

284 int SpdyConstants::SerializeSettingId(SpdyMajorVersion version,

285 SpdySettingsIds id) {

286 switch (version) {

287 case SPDY2:

288 case SPDY3:

289 switch (id) {

290 case SETTINGS_UPLOAD_BANDWIDTH:

291 return 1;

292 case SETTINGS_DOWNLOAD_BANDWIDTH:

293 return 2;

294 case SETTINGS_ROUND_TRIP_TIME:

295 return 3;

296 case SETTINGS_MAX_CONCURRENT_STREAMS:

297 return 4;

298 case SETTINGS_CURRENT_CWND:

299 return 5;

300 case SETTINGS_DOWNLOAD_RETRANS_RATE:

301 return 6;

302 case SETTINGS_INITIAL_WINDOW_SIZE:

303 return 7;

304 default:

305 LOG(DFATAL) << "Serializing unhandled setting id " << id;

306 return -1;

307 }

308 case SPDY4:

309 switch (id) {

310 case SETTINGS_HEADER_TABLE_SIZE:

311 return 1;

312 case SETTINGS_ENABLE_PUSH:

313 return 2;

314 case SETTINGS_MAX_CONCURRENT_STREAMS:

315 return 3;

316 case SETTINGS_INITIAL_WINDOW_SIZE:

317 return 4;

318 case SETTINGS_MAX_FRAME_SIZE:

319 return 5;

320 case SETTINGS_MAX_HEADER_LIST_SIZE:

321 return 6;

322 default:

323 LOG(DFATAL) << "Serializing unhandled setting id " << id;

324 return -1;

325 }

326 }

327 LOG(DFATAL) << "Unhandled SPDY version " << version;

328 return -1;

329 }

330

331 bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,

332 int rst_stream_status_field) {

333 switch (version) {

334 case SPDY2:

335 case SPDY3:

336 // PROTOCOL_ERROR is the valid first status code.

337 if (rst_stream_status_field <

338 SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_ERROR)) {

339 return false;

340 }

341

342 // FRAME_TOO_LARGE is the valid last status code.

343 if (rst_stream_status_field >

344 SerializeRstStreamStatus(version, RST_STREAM_FRAME_TOO_LARGE)) {

345 return false;

346 }

347

348 return true;

349 case SPDY4:

350 // NO_ERROR is the first valid status code.

351 if (rst_stream_status_field <

352 SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_ERROR)) {

353 return false;

354 }

355

356 // TODO(hkhalil): Omit COMPRESSION_ERROR and SETTINGS_TIMEOUT

357 /*

358 // This works because GOAWAY and RST_STREAM share a namespace.

359 if (rst_stream_status_field ==

360 SerializeGoAwayStatus(version, GOAWAY_COMPRESSION_ERROR) \|\|

361 rst_stream_status_field ==

362 SerializeGoAwayStatus(version, GOAWAY_SETTINGS_TIMEOUT)) {

363 return false;

364 }

365 */

366

367 // HTTP_1_1_REQUIRED is the last valid status code.

368 if (rst_stream_status_field >

369 SerializeRstStreamStatus(version, RST_STREAM_HTTP_1_1_REQUIRED)) {

370 return false;

371 }

372

373 return true;

374 }

375 LOG(DFATAL) << "Unhandled SPDY version " << version;

376 return false;

377 }

378

379 SpdyRstStreamStatus SpdyConstants::ParseRstStreamStatus(

380 SpdyMajorVersion version,

381 int rst_stream_status_field) {

382 switch (version) {

383 case SPDY2:

384 case SPDY3:

385 switch (rst_stream_status_field) {

386 case 1:

387 return RST_STREAM_PROTOCOL_ERROR;

388 case 2:

389 return RST_STREAM_INVALID_STREAM;

390 case 3:

391 return RST_STREAM_REFUSED_STREAM;

392 case 4:

393 return RST_STREAM_UNSUPPORTED_VERSION;

394 case 5:

395 return RST_STREAM_CANCEL;

396 case 6:

397 return RST_STREAM_INTERNAL_ERROR;

398 case 7:

399 return RST_STREAM_FLOW_CONTROL_ERROR;

400 case 8:

401 return RST_STREAM_STREAM_IN_USE;

402 case 9:

403 return RST_STREAM_STREAM_ALREADY_CLOSED;

404 case 10:

405 return RST_STREAM_INVALID_CREDENTIALS;

406 case 11:

407 return RST_STREAM_FRAME_TOO_LARGE;

408 }

409 break;

410 case SPDY4:

411 switch (rst_stream_status_field) {

412 case 1:

413 return RST_STREAM_PROTOCOL_ERROR;

414 case 2:

415 return RST_STREAM_INTERNAL_ERROR;

416 case 3:

417 return RST_STREAM_FLOW_CONTROL_ERROR;

418 case 5:

419 return RST_STREAM_STREAM_CLOSED;

420 case 6:

421 return RST_STREAM_FRAME_SIZE_ERROR;

422 case 7:

423 return RST_STREAM_REFUSED_STREAM;

424 case 8:

425 return RST_STREAM_CANCEL;

426 case 10:

427 return RST_STREAM_CONNECT_ERROR;

428 case 11:

429 return RST_STREAM_ENHANCE_YOUR_CALM;

430 case 12:

431 return RST_STREAM_INADEQUATE_SECURITY;

432 case 13:

433 return RST_STREAM_HTTP_1_1_REQUIRED;

434 }

435 break;

436 }

437

438 LOG(DFATAL) << "Invalid RST_STREAM status " << rst_stream_status_field;

439 return RST_STREAM_PROTOCOL_ERROR;

440 }

441

442 int SpdyConstants::SerializeRstStreamStatus(

443 SpdyMajorVersion version,

444 SpdyRstStreamStatus rst_stream_status) {

445 switch (version) {

446 case SPDY2:

447 case SPDY3:

448 switch (rst_stream_status) {

449 case RST_STREAM_PROTOCOL_ERROR:

450 return 1;

451 case RST_STREAM_INVALID_STREAM:

452 return 2;

453 case RST_STREAM_REFUSED_STREAM:

454 return 3;

455 case RST_STREAM_UNSUPPORTED_VERSION:

456 return 4;

457 case RST_STREAM_CANCEL:

458 return 5;

459 case RST_STREAM_INTERNAL_ERROR:

460 return 6;

461 case RST_STREAM_FLOW_CONTROL_ERROR:

462 return 7;

463 case RST_STREAM_STREAM_IN_USE:

464 return 8;

465 case RST_STREAM_STREAM_ALREADY_CLOSED:

466 return 9;

467 case RST_STREAM_INVALID_CREDENTIALS:

468 return 10;

469 case RST_STREAM_FRAME_TOO_LARGE:

470 return 11;

471 default:

472 LOG(DFATAL) << "Unhandled RST_STREAM status "

473 << rst_stream_status;

474 return -1;

475 }

476 case SPDY4:

477 switch (rst_stream_status) {

478 case RST_STREAM_PROTOCOL_ERROR:

479 return 1;

480 case RST_STREAM_INTERNAL_ERROR:

481 return 2;

482 case RST_STREAM_FLOW_CONTROL_ERROR:

483 return 3;

484 case RST_STREAM_STREAM_CLOSED:

485 return 5;

486 case RST_STREAM_FRAME_SIZE_ERROR:

487 return 6;

488 case RST_STREAM_REFUSED_STREAM:

489 return 7;

490 case RST_STREAM_CANCEL:

491 return 8;

492 case RST_STREAM_CONNECT_ERROR:

493 return 10;

494 case RST_STREAM_ENHANCE_YOUR_CALM:

495 return 11;

496 case RST_STREAM_INADEQUATE_SECURITY:

497 return 12;

498 case RST_STREAM_HTTP_1_1_REQUIRED:

499 return 13;

500 default:

501 LOG(DFATAL) << "Unhandled RST_STREAM status "

502 << rst_stream_status;

503 return -1;

504 }

505 }

506 LOG(DFATAL) << "Unhandled SPDY version " << version;

507 return -1;

508 }

509

510 bool SpdyConstants::IsValidGoAwayStatus(SpdyMajorVersion version,

511 int goaway_status_field) {

512 switch (version) {

513 case SPDY2:

514 case SPDY3:

515 // GOAWAY_OK is the first valid status.

516 if (goaway_status_field < SerializeGoAwayStatus(version, GOAWAY_OK)) {

517 return false;

518 }

519

520 // GOAWAY_INTERNAL_ERROR is the last valid status.

521 if (goaway_status_field > SerializeGoAwayStatus(version,

522 GOAWAY_INTERNAL_ERROR)) {

523 return false;

524 }

525

526 return true;

527 case SPDY4:

528 // GOAWAY_NO_ERROR is the first valid status.

529 if (goaway_status_field < SerializeGoAwayStatus(version,

530 GOAWAY_NO_ERROR)) {

531 return false;

532 }

533

534 // GOAWAY_HTTP_1_1_REQUIRED is the last valid status.

535 if (goaway_status_field >

536 SerializeGoAwayStatus(version, GOAWAY_HTTP_1_1_REQUIRED)) {

537 return false;

538 }

539

540 return true;

541 }

542 LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;

543 return false;

544 }

545

546 SpdyGoAwayStatus SpdyConstants::ParseGoAwayStatus(SpdyMajorVersion version,

547 int goaway_status_field) {

548 switch (version) {

549 case SPDY2:

550 case SPDY3:

551 switch (goaway_status_field) {

552 case 0:

553 return GOAWAY_OK;

554 case 1:

555 return GOAWAY_PROTOCOL_ERROR;

556 case 2:

557 return GOAWAY_INTERNAL_ERROR;

558 }

559 break;

560 case SPDY4:

561 switch (goaway_status_field) {

562 case 0:

563 return GOAWAY_NO_ERROR;

564 case 1:

565 return GOAWAY_PROTOCOL_ERROR;

566 case 2:

567 return GOAWAY_INTERNAL_ERROR;

568 case 3:

569 return GOAWAY_FLOW_CONTROL_ERROR;

570 case 4:

571 return GOAWAY_SETTINGS_TIMEOUT;

572 case 5:

573 return GOAWAY_STREAM_CLOSED;

574 case 6:

575 return GOAWAY_FRAME_SIZE_ERROR;

576 case 7:

577 return GOAWAY_REFUSED_STREAM;

578 case 8:

579 return GOAWAY_CANCEL;

580 case 9:

581 return GOAWAY_COMPRESSION_ERROR;

582 case 10:

583 return GOAWAY_CONNECT_ERROR;

584 case 11:

585 return GOAWAY_ENHANCE_YOUR_CALM;

586 case 12:

587 return GOAWAY_INADEQUATE_SECURITY;

588 case 13:

589 return GOAWAY_HTTP_1_1_REQUIRED;

590 }

591 break;

592 }

593

594 LOG(DFATAL) << "Unhandled GOAWAY status " << goaway_status_field;

595 return GOAWAY_PROTOCOL_ERROR;

596 }

597

598 SpdyMajorVersion SpdyConstants::ParseMajorVersion(int version_number) {

599 switch (version_number) {

600 case 2:

601 return SPDY2;

602 case 3:

603 return SPDY3;

604 case 4:

605 return SPDY4;

606 default:

607 LOG(DFATAL) << "Unsupported SPDY version number: " << version_number;

608 return SPDY3;

609 }

610 }

611

612 int SpdyConstants::SerializeMajorVersion(SpdyMajorVersion version) {

613 switch (version) {

614 case SPDY2:

615 return 2;

616 case SPDY3:

617 return 3;

618 case SPDY4:

619 return 4;

620 default:

621 LOG(DFATAL) << "Unsupported SPDY major version: " << version;

622 return -1;

623 }

624 }

625

626 std::string SpdyConstants::GetVersionString(SpdyMajorVersion version) {

627 switch (version) {

628 case SPDY2:

629 return "spdy/2";

630 case SPDY3:

631 return "spdy/3";

632 case SPDY4:

633 return "h2-14";

634 default:

635 LOG(DFATAL) << "Unsupported SPDY major version: " << version;

636 return "spdy/3";

637 }

638 }

639

640 int SpdyConstants::SerializeGoAwayStatus(SpdyMajorVersion version,

641 SpdyGoAwayStatus status) {

642 switch (version) {

643 case SPDY2:

644 case SPDY3:

645 // TODO(jgraettinger): Merge this back to server-side.

646 switch (status) {

647 case GOAWAY_NO_ERROR:

648 return 0;

649 case GOAWAY_PROTOCOL_ERROR:

650 case GOAWAY_INTERNAL_ERROR:

651 case GOAWAY_FLOW_CONTROL_ERROR:

652 case GOAWAY_SETTINGS_TIMEOUT:

653 case GOAWAY_STREAM_CLOSED:

654 case GOAWAY_FRAME_SIZE_ERROR:

655 case GOAWAY_REFUSED_STREAM:

656 case GOAWAY_CANCEL:

657 case GOAWAY_COMPRESSION_ERROR:

658 case GOAWAY_CONNECT_ERROR:

659 case GOAWAY_ENHANCE_YOUR_CALM:

660 case GOAWAY_INADEQUATE_SECURITY:

661 case GOAWAY_HTTP_1_1_REQUIRED:

662 return 1; // PROTOCOL_ERROR.

663 default:

664 LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;

665 return -1;

666 }

667 case SPDY4:

668 switch (status) {

669 case GOAWAY_NO_ERROR:

670 return 0;

671 case GOAWAY_PROTOCOL_ERROR:

672 return 1;

673 case GOAWAY_INTERNAL_ERROR:

674 return 2;

675 case GOAWAY_FLOW_CONTROL_ERROR:

676 return 3;

677 case GOAWAY_SETTINGS_TIMEOUT:

678 return 4;

679 case GOAWAY_STREAM_CLOSED:

680 return 5;

681 case GOAWAY_FRAME_SIZE_ERROR:

682 return 6;

683 case GOAWAY_REFUSED_STREAM:

684 return 7;

685 case GOAWAY_CANCEL:

686 return 8;

687 case GOAWAY_COMPRESSION_ERROR:

688 return 9;

689 case GOAWAY_CONNECT_ERROR:

690 return 10;

691 case GOAWAY_ENHANCE_YOUR_CALM:

692 return 11;

693 case GOAWAY_INADEQUATE_SECURITY:

694 return 12;

695 case GOAWAY_HTTP_1_1_REQUIRED:

696 return 13;

697 default:

698 LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;

699 return -1;

700 }

701 }

702 LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;

703 return -1;

704 }

705

706 size_t SpdyConstants::GetDataFrameMinimumSize(SpdyMajorVersion version) {

707 switch (version) {

708 case SPDY2:

709 case SPDY3:

710 return 8;

711 case SPDY4:

712 return 9;

713 }

714 LOG(DFATAL) << "Unhandled SPDY version.";

715 return 0;

716 }

717

718 size_t SpdyConstants::GetControlFrameHeaderSize(SpdyMajorVersion version) {

719 switch (version) {

720 case SPDY2:

721 case SPDY3:

722 return 8;

723 case SPDY4:

724 return 9;

725 }

726 LOG(DFATAL) << "Unhandled SPDY version.";

727 return 0;

728 }

729

730 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,

731 SpdyMajorVersion version) {

732 if (type != DATA) {

733 return GetControlFrameHeaderSize(version);

734 } else {

735 return GetDataFrameMinimumSize(version);

736 }

737 }

738

739 size_t SpdyConstants::GetFrameMaximumSize(SpdyMajorVersion version) {

740 if (version < SPDY4) {

741 // 24-bit length field plus eight-byte frame header.

742 return ((1<<24) - 1) + 8;

743 } else {

744 // Max payload of 2^14 plus nine-byte frame header.

745 // TODO(mlavan): In HTTP/2 this is actually not a constant;

746 // payload size can be set using the MAX_FRAME_SIZE setting to

747 // anything between 1 << 14 and (1 << 24) - 1

748 return (1 << 14) + 9;

749 }

750 }

751

752 size_t SpdyConstants::GetSizeOfSizeField(SpdyMajorVersion version) {

753 return (version < SPDY3) ? sizeof(uint16) : sizeof(uint32);

754 }

755

756 size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {

757 return version <= SPDY3 ? 8 : 6;

758 }

759

760 int32 SpdyConstants::GetInitialStreamWindowSize(SpdyMajorVersion version) {

761 return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);

762 }

763

764 int32 SpdyConstants::GetInitialSessionWindowSize(SpdyMajorVersion version) {

765 return (version <= SPDY3) ? (64 * 1024) : (64 * 1024 - 1);

766 }

767

768 void SpdyDataIR::Visit(SpdyFrameVisitor* visitor) const {

769 return visitor->VisitData(*this);

770 }

771

772 void SpdySynStreamIR::Visit(SpdyFrameVisitor* visitor) const {

773 return visitor->VisitSynStream(*this);

774 }

775

776 void SpdySynReplyIR::Visit(SpdyFrameVisitor* visitor) const {

777 return visitor->VisitSynReply(*this);

778 }

779

780 SpdyRstStreamIR::SpdyRstStreamIR(SpdyStreamId stream_id,

781 SpdyRstStreamStatus status,

782 base::StringPiece description)

783 : SpdyFrameWithStreamIdIR(stream_id),

784 description_(description) {

785 set_status(status);

786 }

787

788 SpdyRstStreamIR::~SpdyRstStreamIR() {}

789

790 void SpdyRstStreamIR::Visit(SpdyFrameVisitor* visitor) const {

791 return visitor->VisitRstStream(*this);

792 }

793

794 SpdySettingsIR::SpdySettingsIR()

795 : clear_settings_(false),

796 is_ack_(false) {}

797

798 SpdySettingsIR::~SpdySettingsIR() {}

799

800 void SpdySettingsIR::Visit(SpdyFrameVisitor* visitor) const {

801 return visitor->VisitSettings(*this);

802 }

803

804 void SpdyPingIR::Visit(SpdyFrameVisitor* visitor) const {

805 return visitor->VisitPing(*this);

806 }

807

808 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,

809 SpdyGoAwayStatus status,

810 const base::StringPiece& description)

811 : description_(description) {

812 set_last_good_stream_id(last_good_stream_id);

813 set_status(status);

814 }

815

816 SpdyGoAwayIR::~SpdyGoAwayIR() {}

817

818 const base::StringPiece& SpdyGoAwayIR::description() const {

819 return description_;

820 }

821

822 void SpdyGoAwayIR::Visit(SpdyFrameVisitor* visitor) const {

823 return visitor->VisitGoAway(*this);

824 }

825

826 void SpdyHeadersIR::Visit(SpdyFrameVisitor* visitor) const {

827 return visitor->VisitHeaders(*this);

828 }

829

830 void SpdyWindowUpdateIR::Visit(SpdyFrameVisitor* visitor) const {

831 return visitor->VisitWindowUpdate(*this);

832 }

833

834 void SpdyBlockedIR::Visit(SpdyFrameVisitor* visitor) const {

835 return visitor->VisitBlocked(*this);

836 }

837

838 void SpdyPushPromiseIR::Visit(SpdyFrameVisitor* visitor) const {

839 return visitor->VisitPushPromise(*this);

840 }

841

842 void SpdyContinuationIR::Visit(SpdyFrameVisitor* visitor) const {

843 return visitor->VisitContinuation(*this);

844 }

845

846 SpdyAltSvcIR::SpdyAltSvcIR(SpdyStreamId stream_id)

847 : SpdyFrameWithStreamIdIR(stream_id),

848 max_age_(0),

849 port_(0) {}

850

851 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {

852 return visitor->VisitAltSvc(*this);

853 }

854

855 SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id)

856 : SpdyFrameWithStreamIdIR(stream_id) {

857 }

858

859 SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id,

860 SpdyStreamId parent_stream_id,

861 uint8 weight,

862 bool exclusive)

863 : SpdyFrameWithStreamIdIR(stream_id),

864 parent_stream_id_(parent_stream_id),

865 weight_(weight),

866 exclusive_(exclusive) {

867 }

868

869 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {

870 return visitor->VisitPriority(*this);

871 }

872

873 } // namespace net

OLD	NEW

« no previous file with comments | « net/spdy/spdy_protocol.h ('k') | net/spdy/spdy_protocol_test.cc » ('j') | no next file with comments »