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