net/spdy/spdy_protocol.cc

   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     case SPDY5:
  46       // DATA is the first valid frame.
  47       if (frame_type_field < SerializeFrameType(version, DATA)) {
  48         return false;
  49       }
  50
  51       // BLOCKED is the last valid frame.
  52       if (frame_type_field > SerializeFrameType(version, BLOCKED)) {
  53         return false;
  54       }
  55
  56       return true;
  57   }
  58
  59   LOG(DFATAL) << "Unhandled SPDY version " << version;
  60   return false;
  61 }
  62
  63 SpdyFrameType SpdyConstants::ParseFrameType(SpdyMajorVersion version,
  64                                             int frame_type_field) {
  65   switch (version) {
  66     case SPDY2:
  67     case SPDY3:
  68       switch (frame_type_field) {
  69         case 1:
  70           return SYN_STREAM;
  71         case 2:
  72           return SYN_REPLY;
  73         case 3:
  74           return RST_STREAM;
  75         case 4:
  76           return SETTINGS;
  77         case 6:
  78           return PING;
  79         case 7:
  80           return GOAWAY;
  81         case 8:
  82           return HEADERS;
  83         case 9:
  84           return WINDOW_UPDATE;
  85       }
  86       break;
  87     case SPDY4:
  88     case SPDY5:
  89       switch (frame_type_field) {
  90         case 0:
  91           return DATA;
  92         case 1:
  93           return HEADERS;
  94         case 2:
  95           return PRIORITY;
  96         case 3:
  97           return RST_STREAM;
  98         case 4:
  99           return SETTINGS;
 100         case 5:
 101           return PUSH_PROMISE;
 102         case 6:
 103           return PING;
 104         case 7:
 105           return GOAWAY;
 106         case 8:
 107           return WINDOW_UPDATE;
 108         case 9:
 109           return CONTINUATION;
 110         case 10:
 111           return ALTSVC;
 112         case 11:
 113           return BLOCKED;
 114       }
 115       break;
 116   }
 117
 118   LOG(DFATAL) << "Unhandled frame type " << frame_type_field;
 119   return DATA;
 120 }
 121
 122 int SpdyConstants::SerializeFrameType(SpdyMajorVersion version,
 123                                       SpdyFrameType frame_type) {
 124   switch (version) {
 125     case SPDY2:
 126     case SPDY3:
 127       switch (frame_type) {
 128         case SYN_STREAM:
 129           return 1;
 130         case SYN_REPLY:
 131           return 2;
 132         case RST_STREAM:
 133           return 3;
 134         case SETTINGS:
 135           return 4;
 136         case PING:
 137           return 6;
 138         case GOAWAY:
 139           return 7;
 140         case HEADERS:
 141           return 8;
 142         case WINDOW_UPDATE:
 143           return 9;
 144         default:
 145           LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;
 146           return -1;
 147       }
 148     case SPDY4:
 149     case SPDY5:
 150       switch (frame_type) {
 151         case DATA:
 152           return 0;
 153         case HEADERS:
 154           return 1;
 155         case PRIORITY:
 156           return 2;
 157         case RST_STREAM:
 158           return 3;
 159         case SETTINGS:
 160           return 4;
 161         case PUSH_PROMISE:
 162           return 5;
 163         case PING:
 164           return 6;
 165         case GOAWAY:
 166           return 7;
 167         case WINDOW_UPDATE:
 168           return 8;
 169         case CONTINUATION:
 170           return 9;
 171         case ALTSVC:
 172           return 10;
 173         case BLOCKED:
 174           return 11;
 175         default:
 176           LOG(DFATAL) << "Serializing unhandled frame type " << frame_type;
 177           return -1;
 178       }
 179   }
 180
 181   LOG(DFATAL) << "Unhandled SPDY version " << version;
 182   return -1;
 183 }
 184
 185 int SpdyConstants::DataFrameType(SpdyMajorVersion version) {
 186   switch (version) {
 187     case SPDY2:
 188     case SPDY3:
 189       return 0;
 190     case SPDY4:
 191     case SPDY5:
 192       return SerializeFrameType(version, DATA);
 193   }
 194
 195   LOG(DFATAL) << "Unhandled SPDY version " << version;
 196   return 0;
 197 }
 198
 199 bool SpdyConstants::IsValidSettingId(SpdyMajorVersion version,
 200                                      int setting_id_field) {
 201   switch (version) {
 202     case SPDY2:
 203     case SPDY3:
 204       // UPLOAD_BANDWIDTH is the first valid setting id.
 205       if (setting_id_field <
 206           SerializeSettingId(version, SETTINGS_UPLOAD_BANDWIDTH)) {
 207         return false;
 208       }
 209
 210       // INITIAL_WINDOW_SIZE is the last valid setting id.
 211       if (setting_id_field >
 212           SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_SIZE)) {
 213         return false;
 214       }
 215
 216       return true;
 217     case SPDY4:
 218     case SPDY5:
 219       // HEADER_TABLE_SIZE is the first valid setting id.
 220       if (setting_id_field <
 221           SerializeSettingId(version, SETTINGS_HEADER_TABLE_SIZE)) {
 222         return false;
 223       }
 224
 225       // INITIAL_WINDOW_SIZE is the last valid setting id.
 226       if (setting_id_field >
 227           SerializeSettingId(version, SETTINGS_INITIAL_WINDOW_SIZE)) {
 228         return false;
 229       }
 230
 231       return true;
 232   }
 233
 234   LOG(DFATAL) << "Unhandled SPDY version " << version;
 235   return false;
 236 }
 237
 238 SpdySettingsIds SpdyConstants::ParseSettingId(SpdyMajorVersion version,
 239                                               int setting_id_field) {
 240   switch (version) {
 241     case SPDY2:
 242     case SPDY3:
 243       switch (setting_id_field) {
 244         case 1:
 245           return SETTINGS_UPLOAD_BANDWIDTH;
 246         case 2:
 247           return SETTINGS_DOWNLOAD_BANDWIDTH;
 248         case 3:
 249           return SETTINGS_ROUND_TRIP_TIME;
 250         case 4:
 251           return SETTINGS_MAX_CONCURRENT_STREAMS;
 252         case 5:
 253           return SETTINGS_CURRENT_CWND;
 254         case 6:
 255           return SETTINGS_DOWNLOAD_RETRANS_RATE;
 256         case 7:
 257           return SETTINGS_INITIAL_WINDOW_SIZE;
 258       }
 259       break;
 260     case SPDY4:
 261     case SPDY5:
 262       switch (setting_id_field) {
 263         case 1:
 264           return SETTINGS_HEADER_TABLE_SIZE;
 265         case 2:
 266           return SETTINGS_ENABLE_PUSH;
 267         case 3:
 268           return SETTINGS_MAX_CONCURRENT_STREAMS;
 269         case 4:
 270           return SETTINGS_INITIAL_WINDOW_SIZE;
 271       }
 272       break;
 273   }
 274
 275   LOG(DFATAL) << "Unhandled setting ID " << setting_id_field;
 276   return SETTINGS_UPLOAD_BANDWIDTH;
 277 }
 278
 279 int SpdyConstants::SerializeSettingId(SpdyMajorVersion version,
 280                                        SpdySettingsIds id) {
 281   switch (version) {
 282     case SPDY2:
 283     case SPDY3:
 284       switch (id) {
 285         case SETTINGS_UPLOAD_BANDWIDTH:
 286           return 1;
 287         case SETTINGS_DOWNLOAD_BANDWIDTH:
 288           return 2;
 289         case SETTINGS_ROUND_TRIP_TIME:
 290           return 3;
 291         case SETTINGS_MAX_CONCURRENT_STREAMS:
 292           return 4;
 293         case SETTINGS_CURRENT_CWND:
 294           return 5;
 295         case SETTINGS_DOWNLOAD_RETRANS_RATE:
 296           return 6;
 297         case SETTINGS_INITIAL_WINDOW_SIZE:
 298           return 7;
 299         default:
 300           LOG(DFATAL) << "Serializing unhandled setting id " << id;
 301           return -1;
 302       }
 303     case SPDY4:
 304     case SPDY5:
 305       switch (id) {
 306         case SETTINGS_HEADER_TABLE_SIZE:
 307           return 1;
 308         case SETTINGS_ENABLE_PUSH:
 309           return 2;
 310         case SETTINGS_MAX_CONCURRENT_STREAMS:
 311           return 3;
 312         case SETTINGS_INITIAL_WINDOW_SIZE:
 313           return 4;
 314         default:
 315           LOG(DFATAL) << "Serializing unhandled setting id " << id;
 316           return -1;
 317       }
 318   }
 319   LOG(DFATAL) << "Unhandled SPDY version " << version;
 320   return -1;
 321 }
 322
 323 bool SpdyConstants::IsValidRstStreamStatus(SpdyMajorVersion version,
 324                                            int rst_stream_status_field) {
 325   switch (version) {
 326     case SPDY2:
 327     case SPDY3:
 328       // PROTOCOL_ERROR is the valid first status code.
 329       if (rst_stream_status_field <
 330           SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_ERROR)) {
 331         return false;
 332       }
 333
 334       // FRAME_TOO_LARGE is the valid last status code.
 335       if (rst_stream_status_field >
 336           SerializeRstStreamStatus(version, RST_STREAM_FRAME_TOO_LARGE)) {
 337         return false;
 338       }
 339
 340       return true;
 341     case SPDY4:
 342     case SPDY5:
 343       // NO_ERROR is the first valid status code.
 344       if (rst_stream_status_field <
 345           SerializeRstStreamStatus(version, RST_STREAM_PROTOCOL_ERROR)) {
 346         return false;
 347       }
 348
 349       // TODO(hkhalil): Omit COMPRESSION_ERROR and SETTINGS_TIMEOUT
 350       /*
 351       // This works because GOAWAY and RST_STREAM share a namespace.
 352       if (rst_stream_status_field ==
 353           SerializeGoAwayStatus(version, GOAWAY_COMPRESSION_ERROR) ||
 354           rst_stream_status_field ==
 355           SerializeGoAwayStatus(version, GOAWAY_SETTINGS_TIMEOUT)) {
 356         return false;
 357       }
 358       */
 359
 360       // ENHANCE_YOUR_CALM is the last valid status code.
 361       if (rst_stream_status_field >
 362           SerializeRstStreamStatus(version, RST_STREAM_ENHANCE_YOUR_CALM)) {
 363         return false;
 364       }
 365
 366       return true;
 367   }
 368   LOG(DFATAL) << "Unhandled SPDY version " << version;
 369   return false;
 370 }
 371
 372 SpdyRstStreamStatus SpdyConstants::ParseRstStreamStatus(
 373     SpdyMajorVersion version,
 374     int rst_stream_status_field) {
 375   switch (version) {
 376     case SPDY2:
 377     case SPDY3:
 378       switch (rst_stream_status_field) {
 379         case 1:
 380           return RST_STREAM_PROTOCOL_ERROR;
 381         case 2:
 382           return RST_STREAM_INVALID_STREAM;
 383         case 3:
 384           return RST_STREAM_REFUSED_STREAM;
 385         case 4:
 386           return RST_STREAM_UNSUPPORTED_VERSION;
 387         case 5:
 388           return RST_STREAM_CANCEL;
 389         case 6:
 390           return RST_STREAM_INTERNAL_ERROR;
 391         case 7:
 392           return RST_STREAM_FLOW_CONTROL_ERROR;
 393         case 8:
 394           return RST_STREAM_STREAM_IN_USE;
 395         case 9:
 396           return RST_STREAM_STREAM_ALREADY_CLOSED;
 397         case 10:
 398           return RST_STREAM_INVALID_CREDENTIALS;
 399         case 11:
 400           return RST_STREAM_FRAME_TOO_LARGE;
 401       }
 402       break;
 403     case SPDY4:
 404     case SPDY5:
 405       switch (rst_stream_status_field) {
 406         case 1:
 407           return RST_STREAM_PROTOCOL_ERROR;
 408         case 2:
 409           return RST_STREAM_INTERNAL_ERROR;
 410         case 3:
 411           return RST_STREAM_FLOW_CONTROL_ERROR;
 412         case 5:
 413           return RST_STREAM_STREAM_CLOSED;
 414         case 6:
 415           return RST_STREAM_FRAME_SIZE_ERROR;
 416         case 7:
 417           return RST_STREAM_REFUSED_STREAM;
 418         case 8:
 419           return RST_STREAM_CANCEL;
 420         case 10:
 421           return RST_STREAM_CONNECT_ERROR;
 422         case 11:
 423           return RST_STREAM_ENHANCE_YOUR_CALM;
 424       }
 425       break;
 426   }
 427
 428   LOG(DFATAL) << "Invalid RST_STREAM status " << rst_stream_status_field;
 429   return RST_STREAM_PROTOCOL_ERROR;
 430 }
 431
 432 int SpdyConstants::SerializeRstStreamStatus(
 433     SpdyMajorVersion version,
 434     SpdyRstStreamStatus rst_stream_status) {
 435   switch (version) {
 436     case SPDY2:
 437     case SPDY3:
 438       switch (rst_stream_status) {
 439         case RST_STREAM_PROTOCOL_ERROR:
 440           return 1;
 441         case RST_STREAM_INVALID_STREAM:
 442           return 2;
 443         case RST_STREAM_REFUSED_STREAM:
 444           return 3;
 445         case RST_STREAM_UNSUPPORTED_VERSION:
 446           return 4;
 447         case RST_STREAM_CANCEL:
 448           return 5;
 449         case RST_STREAM_INTERNAL_ERROR:
 450           return 6;
 451         case RST_STREAM_FLOW_CONTROL_ERROR:
 452           return 7;
 453         case RST_STREAM_STREAM_IN_USE:
 454           return 8;
 455         case RST_STREAM_STREAM_ALREADY_CLOSED:
 456           return 9;
 457         case RST_STREAM_INVALID_CREDENTIALS:
 458           return 10;
 459         case RST_STREAM_FRAME_TOO_LARGE:
 460           return 11;
 461         default:
 462           LOG(DFATAL) << "Unhandled RST_STREAM status "
 463                       << rst_stream_status;
 464           return -1;
 465       }
 466     case SPDY4:
 467     case SPDY5:
 468       switch (rst_stream_status) {
 469         case RST_STREAM_PROTOCOL_ERROR:
 470           return 1;
 471         case RST_STREAM_INTERNAL_ERROR:
 472           return 2;
 473         case RST_STREAM_FLOW_CONTROL_ERROR:
 474           return 3;
 475         case RST_STREAM_STREAM_CLOSED:
 476           return 5;
 477         case RST_STREAM_FRAME_SIZE_ERROR:
 478           return 6;
 479         case RST_STREAM_REFUSED_STREAM:
 480           return 7;
 481         case RST_STREAM_CANCEL:
 482           return 8;
 483         case RST_STREAM_CONNECT_ERROR:
 484           return 10;
 485         case RST_STREAM_ENHANCE_YOUR_CALM:
 486           return 11;
 487         default:
 488           LOG(DFATAL) << "Unhandled RST_STREAM status "
 489                       << rst_stream_status;
 490           return -1;
 491       }
 492   }
 493   LOG(DFATAL) << "Unhandled SPDY version " << version;
 494   return -1;
 495 }
 496
 497 bool SpdyConstants::IsValidGoAwayStatus(SpdyMajorVersion version,
 498                                         int goaway_status_field) {
 499   switch (version) {
 500     case SPDY2:
 501     case SPDY3:
 502       // GOAWAY_OK is the first valid status.
 503       if (goaway_status_field < SerializeGoAwayStatus(version, GOAWAY_OK)) {
 504         return false;
 505       }
 506
 507       // GOAWAY_INTERNAL_ERROR is the last valid status.
 508       if (goaway_status_field > SerializeGoAwayStatus(version,
 509                                                       GOAWAY_INTERNAL_ERROR)) {
 510         return false;
 511       }
 512
 513       return true;
 514     case SPDY4:
 515     case SPDY5:
 516       // GOAWAY_NO_ERROR is the first valid status.
 517       if (goaway_status_field < SerializeGoAwayStatus(version,
 518                                                       GOAWAY_NO_ERROR)) {
 519         return false;
 520       }
 521
 522       // GOAWAY_INADEQUATE_SECURITY is the last valid status.
 523       if (goaway_status_field >
 524           SerializeGoAwayStatus(version, GOAWAY_INADEQUATE_SECURITY)) {
 525         return false;
 526       }
 527
 528       return true;
 529   }
 530   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
 531   return false;
 532 }
 533
 534 SpdyGoAwayStatus SpdyConstants::ParseGoAwayStatus(SpdyMajorVersion version,
 535                                                   int goaway_status_field) {
 536   switch (version) {
 537     case SPDY2:
 538     case SPDY3:
 539       switch (goaway_status_field) {
 540         case 0:
 541           return GOAWAY_OK;
 542         case 1:
 543           return GOAWAY_PROTOCOL_ERROR;
 544         case 2:
 545           return GOAWAY_INTERNAL_ERROR;
 546       }
 547       break;
 548     case SPDY4:
 549     case SPDY5:
 550       switch (goaway_status_field) {
 551         case 0:
 552           return GOAWAY_NO_ERROR;
 553         case 1:
 554           return GOAWAY_PROTOCOL_ERROR;
 555         case 2:
 556           return GOAWAY_INTERNAL_ERROR;
 557         case 3:
 558           return GOAWAY_FLOW_CONTROL_ERROR;
 559         case 4:
 560           return GOAWAY_SETTINGS_TIMEOUT;
 561         case 5:
 562           return GOAWAY_STREAM_CLOSED;
 563         case 6:
 564           return GOAWAY_FRAME_SIZE_ERROR;
 565         case 7:
 566           return GOAWAY_REFUSED_STREAM;
 567         case 8:
 568           return GOAWAY_CANCEL;
 569         case 9:
 570           return GOAWAY_COMPRESSION_ERROR;
 571         case 10:
 572           return GOAWAY_CONNECT_ERROR;
 573         case 11:
 574           return GOAWAY_ENHANCE_YOUR_CALM;
 575         case 12:
 576           return GOAWAY_INADEQUATE_SECURITY;
 577       }
 578       break;
 579   }
 580
 581   LOG(DFATAL) << "Unhandled GOAWAY status " << goaway_status_field;
 582   return GOAWAY_PROTOCOL_ERROR;
 583 }
 584
 585 SpdyMajorVersion SpdyConstants::ParseMajorVersion(int version_number) {
 586   switch (version_number) {
 587     case 2:
 588       return SPDY2;
 589     case 3:
 590       return SPDY3;
 591     case 4:
 592       return SPDY4;
 593     case 5:
 594       return SPDY5;
 595     default:
 596       LOG(DFATAL) << "Unsupported SPDY version number: " << version_number;
 597       return SPDY3;
 598   }
 599 }
 600
 601 int SpdyConstants::SerializeMajorVersion(SpdyMajorVersion version) {
 602   switch (version) {
 603     case SPDY2:
 604       return 2;
 605     case SPDY3:
 606       return 3;
 607     case SPDY4:
 608       return 4;
 609     case SPDY5:
 610       return 5;
 611     default:
 612       LOG(DFATAL) << "Unsupported SPDY major version: " << version;
 613       return -1;
 614   }
 615 }
 616
 617 std::string SpdyConstants::GetVersionString(SpdyMajorVersion version) {
 618   switch (version) {
 619     case SPDY2:
 620       return "spdy/2";
 621     case SPDY3:
 622       return "spdy/3";
 623     case SPDY4:
 624       return "spdy/4";
 625     case SPDY5:
 626       return "spdy/5";
 627     default:
 628       LOG(DFATAL) << "Unsupported SPDY major version: " << version;
 629       return "spdy/3";
 630   }
 631 }
 632
 633 int SpdyConstants::SerializeGoAwayStatus(SpdyMajorVersion version,
 634                                          SpdyGoAwayStatus status) {
 635   switch (version) {
 636     case SPDY2:
 637     case SPDY3:
 638       // TODO(jgraettinger): Merge this back to server-side.
 639       switch (status) {
 640         case GOAWAY_NO_ERROR:
 641           return 0;
 642         case GOAWAY_PROTOCOL_ERROR:
 643         case GOAWAY_INTERNAL_ERROR:
 644         case GOAWAY_FLOW_CONTROL_ERROR:
 645         case GOAWAY_SETTINGS_TIMEOUT:
 646         case GOAWAY_STREAM_CLOSED:
 647         case GOAWAY_FRAME_SIZE_ERROR:
 648         case GOAWAY_REFUSED_STREAM:
 649         case GOAWAY_CANCEL:
 650         case GOAWAY_COMPRESSION_ERROR:
 651         case GOAWAY_CONNECT_ERROR:
 652         case GOAWAY_ENHANCE_YOUR_CALM:
 653         case GOAWAY_INADEQUATE_SECURITY:
 654           return 1;  // PROTOCOL_ERROR.
 655         default:
 656           LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;
 657           return -1;
 658       }
 659     case SPDY4:
 660     case SPDY5:
 661       switch (status) {
 662         case GOAWAY_NO_ERROR:
 663           return 0;
 664         case GOAWAY_PROTOCOL_ERROR:
 665           return 1;
 666         case GOAWAY_INTERNAL_ERROR:
 667           return 2;
 668         case GOAWAY_FLOW_CONTROL_ERROR:
 669           return 3;
 670         case GOAWAY_SETTINGS_TIMEOUT:
 671           return 4;
 672         case GOAWAY_STREAM_CLOSED:
 673           return 5;
 674         case GOAWAY_FRAME_SIZE_ERROR:
 675           return 6;
 676         case GOAWAY_REFUSED_STREAM:
 677           return 7;
 678         case GOAWAY_CANCEL:
 679           return 8;
 680         case GOAWAY_COMPRESSION_ERROR:
 681           return 9;
 682         case GOAWAY_CONNECT_ERROR:
 683           return 10;
 684         case GOAWAY_ENHANCE_YOUR_CALM:
 685           return 11;
 686         case GOAWAY_INADEQUATE_SECURITY:
 687           return 12;
 688         default:
 689           LOG(DFATAL) << "Serializing unhandled GOAWAY status " << status;
 690           return -1;
 691       }
 692   }
 693   LOG(DFATAL) << "Unknown SpdyMajorVersion " << version;
 694   return -1;
 695 }
 696
 697 size_t SpdyConstants::GetDataFrameMinimumSize() {
 698   return 8;
 699 }
 700
 701 size_t SpdyConstants::GetControlFrameHeaderSize(SpdyMajorVersion version) {
 702   switch (version) {
 703     case SPDY2:
 704     case SPDY3:
 705     case SPDY4:
 706     case SPDY5:
 707       return 8;
 708   }
 709   LOG(DFATAL) << "Unhandled SPDY version.";
 710   return 0;
 711 }
 712
 713 size_t SpdyConstants::GetPrefixLength(SpdyFrameType type,
 714                                       SpdyMajorVersion version) {
 715   if (type != DATA) {
 716      return GetControlFrameHeaderSize(version);
 717   } else {
 718      return GetDataFrameMinimumSize();
 719   }
 720 }
 721
 722 size_t SpdyConstants::GetFrameMaximumSize(SpdyMajorVersion version) {
 723   if (version < SPDY4) {
 724     // 24-bit length field plus eight-byte frame header.
 725     return ((1<<24) - 1) + 8;
 726   } else {
 727     // 14-bit length field.
 728     return (1<<14) - 1;
 729   }
 730 }
 731
 732 size_t SpdyConstants::GetSizeOfSizeField(SpdyMajorVersion version) {
 733   return (version < SPDY3) ? sizeof(uint16) : sizeof(uint32);
 734 }
 735
 736 size_t SpdyConstants::GetSettingSize(SpdyMajorVersion version) {
 737   return version <= SPDY3 ? 8 : 6;
 738 }
 739
 740 void SpdyDataIR::Visit(SpdyFrameVisitor* visitor) const {
 741   return visitor->VisitData(*this);
 742 }
 743
 744 void SpdySynStreamIR::Visit(SpdyFrameVisitor* visitor) const {
 745   return visitor->VisitSynStream(*this);
 746 }
 747
 748 void SpdySynReplyIR::Visit(SpdyFrameVisitor* visitor) const {
 749   return visitor->VisitSynReply(*this);
 750 }
 751
 752 SpdyRstStreamIR::SpdyRstStreamIR(SpdyStreamId stream_id,
 753                                  SpdyRstStreamStatus status,
 754                                  base::StringPiece description)
 755     : SpdyFrameWithStreamIdIR(stream_id),
 756       description_(description) {
 757   set_status(status);
 758 }
 759
 760 SpdyRstStreamIR::~SpdyRstStreamIR() {}
 761
 762 void SpdyRstStreamIR::Visit(SpdyFrameVisitor* visitor) const {
 763   return visitor->VisitRstStream(*this);
 764 }
 765
 766 SpdySettingsIR::SpdySettingsIR()
 767     : clear_settings_(false),
 768       is_ack_(false) {}
 769
 770 SpdySettingsIR::~SpdySettingsIR() {}
 771
 772 void SpdySettingsIR::Visit(SpdyFrameVisitor* visitor) const {
 773   return visitor->VisitSettings(*this);
 774 }
 775
 776 void SpdyPingIR::Visit(SpdyFrameVisitor* visitor) const {
 777   return visitor->VisitPing(*this);
 778 }
 779
 780 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
 781                            SpdyGoAwayStatus status,
 782                            const base::StringPiece& description)
 783     : description_(description) {
 784       set_last_good_stream_id(last_good_stream_id);
 785   set_status(status);
 786 }
 787
 788 SpdyGoAwayIR::~SpdyGoAwayIR() {}
 789
 790 const base::StringPiece& SpdyGoAwayIR::description() const {
 791   return description_;
 792 }
 793
 794 void SpdyGoAwayIR::Visit(SpdyFrameVisitor* visitor) const {
 795   return visitor->VisitGoAway(*this);
 796 }
 797
 798 void SpdyHeadersIR::Visit(SpdyFrameVisitor* visitor) const {
 799   return visitor->VisitHeaders(*this);
 800 }
 801
 802 void SpdyWindowUpdateIR::Visit(SpdyFrameVisitor* visitor) const {
 803   return visitor->VisitWindowUpdate(*this);
 804 }
 805
 806 void SpdyBlockedIR::Visit(SpdyFrameVisitor* visitor) const {
 807   return visitor->VisitBlocked(*this);
 808 }
 809
 810 void SpdyPushPromiseIR::Visit(SpdyFrameVisitor* visitor) const {
 811   return visitor->VisitPushPromise(*this);
 812 }
 813
 814 void SpdyContinuationIR::Visit(SpdyFrameVisitor* visitor) const {
 815   return visitor->VisitContinuation(*this);
 816 }
 817
 818 SpdyAltSvcIR::SpdyAltSvcIR(SpdyStreamId stream_id)
 819     : SpdyFrameWithStreamIdIR(stream_id),
 820       max_age_(0),
 821       port_(0) {}
 822
 823 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {
 824   return visitor->VisitAltSvc(*this);
 825 }
 826
 827 SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id)
 828     : SpdyFrameWithStreamIdIR(stream_id) {
 829 }
 830
 831 SpdyPriorityIR::SpdyPriorityIR(SpdyStreamId stream_id,
 832                                SpdyStreamId parent_stream_id,
 833                                uint8 weight,
 834                                bool exclusive)
 835     : SpdyFrameWithStreamIdIR(stream_id),
 836       parent_stream_id_(parent_stream_id),
 837       weight_(weight),
 838       exclusive_(exclusive) {
 839 }
 840
 841 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
 842   return visitor->VisitPriority(*this);
 843 }
 844
 845 }  // namespace net