Centralize logic for calculating (minimum) size of SPDY frames, by type, in SpdyFramer.

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 137 matching lines @@
   state_ = SPDY_RESET;
   previous_state_ = SPDY_RESET;
   error_code_ = SPDY_NO_ERROR;
   remaining_data_ = 0;
   remaining_control_payload_ = 0;
   remaining_control_header_ = 0;
   current_frame_len_ = 0;
   settings_scratch_.Reset();
 }
 
+size_t SpdyFramer::GetControlFrameMinimumSize() const {
+  // Size, in bytes, of the control frame header. Future versions of SPDY
+  // will likely vary this, so we allow for the flexibility of a function call
+  // for this value as opposed to a constant.
+  return 8;
+}
+
+size_t SpdyFramer::GetSynStreamMinimumSize() const {
+  // Size, in bytes, of a SYN_STREAM frame not including the variable-length
+  // name-value block. Calculated as:
+  // control frame header + 2 * 4 (stream IDs) + 1 (priority) + 1 (slot)
+  return GetControlFrameMinimumSize() + 10;
+}
+
+size_t SpdyFramer::GetSynReplyMinimumSize() const {
+  // Size, in bytes, of a SYN_REPLY frame not including the variable-length
+  // name-value block. Calculated as:
+  // control frame header + 4 (stream ID)
+  size_t size = GetControlFrameMinimumSize() + 4;
+
+  // In SPDY 2, there were 2 unused bytes before payload.
+  if (protocol_version() < 3) {
+    size += 2;
+  }
+
+  return size;
+}
+
+size_t SpdyFramer::GetRstStreamSize() const {
+  // Size, in bytes, of a RST_STREAM frame. Calculated as:
+  // control frame header + 4 (stream id) + 4 (status code)
+  return GetControlFrameMinimumSize() + 8;
+}
+
+size_t SpdyFramer::GetSettingsMinimumSize() const {
+  // Size, in bytes, of a SETTINGS frame not including the IDs and values
+  // from the variable-length value block. Calculated as:
+  // control frame header + 4 (number of ID/value pairs)
+  return GetControlFrameMinimumSize() + 4;
+}
+
+size_t SpdyFramer::GetPingSize() const {
+  // Size, in bytes, of this PING frame. Calculated as:
+  // control frame header + 4 (id)
+  return GetControlFrameMinimumSize() + 4;
+}
+
+size_t SpdyFramer::GetGoAwaySize() const {
+  // Size, in bytes, of this GOAWAY frame. Calculated as:
+  // control frame header + 4 (last good stream id)
+  size_t size = GetControlFrameMinimumSize() + 4;
+
+  // SPDY 3+ GOAWAY frames also contain a status.
+  if (protocol_version() >= 3) {
+    size += 4;
+  }
+
+  return size;
+}
+
+size_t SpdyFramer::GetHeadersMinimumSize() const  {
+  // Size, in bytes, of a HEADERS frame not including the variable-length
+  // name-value block. Calculated as:
+  // control frame header + 4 (stream ID)
+  size_t size = GetControlFrameMinimumSize() + 4;
+
+  // In SPDY 2, there were 2 unused bytes before payload.
+  if (protocol_version() < 3) {
+    size += 2;
+  }
+
+  return size;
+}
+
+size_t SpdyFramer::GetWindowUpdateSize() const {
+  // Size, in bytes, of this WINDOW_UPDATE frame. Calculated as:
+  // control frame header + 4 (stream id) + 4 (delta)
+  return GetControlFrameMinimumSize() + 8;
+}
+
+size_t SpdyFramer::GetCredentialMinimumSize() const {
+  // Size, in bytes, of a CREDENTIAL frame sans variable-length certificate list
+  // and proof. Calculated as:
+  // control frame header + 2 (slot)
+  return GetControlFrameMinimumSize() + 2;
+}
+
 const char* SpdyFramer::StateToString(int state) {
   switch (state) {
     case SPDY_ERROR:
       return "ERROR";
     case SPDY_DONE:
       return "DONE";
     case SPDY_AUTO_RESET:
       return "AUTO_RESET";
     case SPDY_RESET:
       return "RESET";
@@ skipping 293 matching lines @@
   if (current_control_frame.type() == NOOP) {
     DLOG(INFO) << "NOOP control frame found. Ignoring.";
     CHANGE_STATE(SPDY_AUTO_RESET);
     return;
   }
 
   // Do some sanity checking on the control frame sizes.
   switch (current_control_frame.type()) {
     case SYN_STREAM:
       if (current_control_frame.length() <
-          SpdySynStreamControlFrame::size() - SpdyControlFrame::kHeaderSize) {
+          GetSynStreamMinimumSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() &
                  ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SYN_REPLY:
       if (current_control_frame.length() <
-          SpdySynReplyControlFrame::size() - SpdyControlFrame::kHeaderSize) {
+          GetSynReplyMinimumSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() & ~CONTROL_FLAG_FIN) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case RST_STREAM:
       if (current_control_frame.length() !=
-          SpdyRstStreamControlFrame::size() - SpdyFrame::kHeaderSize) {
+          GetRstStreamSize() - SpdyFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SETTINGS:
       // Make sure that we have an integral number of 8-byte key/value pairs,
       // plus a 4-byte length field.
       if (current_control_frame.length() <
-          SpdySettingsControlFrame::size() - SpdyControlFrame::kHeaderSize ||
+          GetSettingsMinimumSize() - SpdyControlFrame::kHeaderSize ||
           (current_control_frame.length() % 8 != 4)) {
         DLOG(WARNING) << "Invalid length for SETTINGS frame: "
                       << current_control_frame.length();
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() &
                  ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case GOAWAY:
       {
-        // SPDY 2 GOAWAY frames are 4 bytes smaller than in SPDY 3. We account
-        // for this difference via a separate offset variable, since
-        // SpdyGoAwayControlFrame::size() returns the SPDY 3 size.
-        const size_t goaway_offset = (protocol_version() < 3) ? 4 : 0;
-        if (current_control_frame.length() + goaway_offset !=
-            SpdyGoAwayControlFrame::size() - SpdyFrame::kHeaderSize) {
+        if (current_control_frame.length() !=
+            GetGoAwaySize() - SpdyFrame::kHeaderSize) {
           set_error(SPDY_INVALID_CONTROL_FRAME);
         } else if (current_control_frame.flags() != 0) {
           set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
         }
         break;
       }
     case HEADERS:
       if (current_control_frame.length() <
-          SpdyHeadersControlFrame::size() - SpdyControlFrame::kHeaderSize) {
+          GetHeadersMinimumSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() & ~CONTROL_FLAG_FIN) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case WINDOW_UPDATE:
       if (current_control_frame.length() !=
-          SpdyWindowUpdateControlFrame::size() -
-          SpdyControlFrame::kHeaderSize) {
+          GetWindowUpdateSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case PING:
       if (current_control_frame.length() !=
-          SpdyPingControlFrame::size() - SpdyControlFrame::kHeaderSize) {
+          GetPingSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CREDENTIAL:
       if (current_control_frame.length() <
-          SpdyCredentialControlFrame::size() - SpdyControlFrame::kHeaderSize) {
+          GetCredentialMinimumSize() - SpdyControlFrame::kHeaderSize) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_control_frame.flags() != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     default:
       LOG(WARNING) << "Valid " << display_protocol_
                    << " control frame with unhandled type: "
                    << current_control_frame.type();
       DLOG(FATAL);
@@ skipping 756 matching lines @@
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (syn_stream.unidirectional()) {
     flags |= CONTROL_FLAG_UNIDIRECTIONAL;
   }
 
-  // The size, in bytes, of this frame not including the variable-length
-  // name-value block. Calculated as:
-  // 8 (control frame header) + 2 * 4 (stream IDs) + 1 (priority) + 1 (slot)
-  const size_t kSynStreamSizeBeforeNameValueBlock = 18;
-
   // The size of this frame, including variable-length name-value block.
-  const size_t size = kSynStreamSizeBeforeNameValueBlock
+  const size_t size = GetSynStreamMinimumSize()
       + GetSerializedLength(protocol_version(),
                             &(syn_stream.name_value_block()));
 
   SpdyFrameBuilder builder(SYN_STREAM, flags, protocol_version(), size);
   builder.WriteUInt32(syn_stream.stream_id());
   builder.WriteUInt32(syn_stream.associated_to_stream_id());
   uint8 priority = syn_stream.priority();
   if (priority > GetLowestPriority()) {
     DLOG(DFATAL) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
   builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
   builder.WriteUInt8(syn_stream.slot());
-  DCHECK_EQ(kSynStreamSizeBeforeNameValueBlock, builder.length());
+  DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_stream);
 
   return builder.take();
 }
 
 SpdySynReplyControlFrame* SpdyFramer::CreateSynReply(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
@@ skipping 14 matching lines @@
   return reply_frame.release();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     const SpdySynReplyIR& syn_reply) {
   uint8 flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
 
-  // The size, in bytes, of this frame not including the variable-length
-  // name-value block. Calculated as:
-  // 8 (control frame header) + 4 (stream ID)
-  size_t syn_reply_size_before_name_value_block = 12;
-  // In SPDY 2, there were 2 unused bytes before payload.
-  if (protocol_version() < 3) {
-    syn_reply_size_before_name_value_block += 2;
-  }
-
   // The size of this frame, including variable-length name-value block.
-  size_t size = syn_reply_size_before_name_value_block
+  size_t size = GetSynReplyMinimumSize()
       + GetSerializedLength(protocol_version(),
                             &(syn_reply.name_value_block()));
 
   SpdyFrameBuilder builder(SYN_REPLY, flags, protocol_version(), size);
   builder.WriteUInt32(syn_reply.stream_id());
   if (protocol_version() < 3) {
     builder.WriteUInt16(0);  // Unused.
   }
-  DCHECK_EQ(syn_reply_size_before_name_value_block, builder.length());
+  DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_reply);
 
   return builder.take();
 }
 
 SpdyRstStreamControlFrame* SpdyFramer::CreateRstStream(
     SpdyStreamId stream_id,
     SpdyRstStreamStatus status) const {
   SpdyRstStreamIR rst_stream(stream_id, status);
   return reinterpret_cast<SpdyRstStreamControlFrame*>(
       SerializeRstStream(rst_stream));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
-  // Size of our RST_STREAM frame. Calculated as:
-  // 8 (control frame header) + 4 (stream id) + 4 (status code)
-  const size_t kRstStreamFrameSize = 16;
-
   SpdyFrameBuilder builder(RST_STREAM,
                            kNoFlags,
                            protocol_version(),
-                           kRstStreamFrameSize);
+                           GetRstStreamSize());
   builder.WriteUInt32(rst_stream.stream_id());
   builder.WriteUInt32(rst_stream.status());
-  DCHECK_EQ(kRstStreamFrameSize, builder.length());
+  DCHECK_EQ(GetRstStreamSize(), builder.length());
   return builder.take();
 }
 
 SpdySettingsControlFrame* SpdyFramer::CreateSettings(
     const SettingsMap& values) const {
   SpdySettingsIR settings;
   for (SettingsMap::const_iterator it = values.begin();
        it != values.end();
        ++it) {
     settings.AddSetting(it->first,
                         (it->second.first & SETTINGS_FLAG_PLEASE_PERSIST) != 0,
                         (it->second.first & SETTINGS_FLAG_PERSISTED) != 0,
                         it->second.second);
   }
   return reinterpret_cast<SpdySettingsControlFrame*>(
       SerializeSettings(settings));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSettings(
     const SpdySettingsIR& settings) const {
   uint8 flags = 0;
   if (settings.clear_settings()) {
     flags |= SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
   }
   const SpdySettingsIR::ValueMap* values = &(settings.values());
 
-  // Size, in bytes, of this SETTINGS frame not including the IDs and values
-  // from the variable-length value block. Calculated as:
-  // 8 (control frame header) + 4 (number of ID/value pairs)
-  const size_t kSettingsSizeWithoutValues = 12;
   // Size, in bytes, of this SETTINGS frame.
-  const size_t size = kSettingsSizeWithoutValues + (values->size() * 8);
+  const size_t size = GetSettingsMinimumSize() + (values->size() * 8);
 
   SpdyFrameBuilder builder(SETTINGS, flags, protocol_version(), size);
   builder.WriteUInt32(values->size());
-  DCHECK_EQ(kSettingsSizeWithoutValues, builder.length());
+  DCHECK_EQ(GetSettingsMinimumSize(), builder.length());
   for (SpdySettingsIR::ValueMap::const_iterator it = values->begin();
        it != values->end();
        ++it) {
     uint8 setting_flags = 0;
     if (it->second.persist_value) {
       setting_flags |= SETTINGS_FLAG_PLEASE_PERSIST;
     }
     if (it->second.persisted) {
       setting_flags |= SETTINGS_FLAG_PERSISTED;
     }
     SettingsFlagsAndId flags_and_id(setting_flags, it->first);
     uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
     builder.WriteBytes(&id_and_flags_wire, 4);
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdyPingControlFrame* SpdyFramer::CreatePingFrame(uint32 unique_id) const {
   SpdyPingIR ping(unique_id);
   return reinterpret_cast<SpdyPingControlFrame*>(SerializePing(ping));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
-  // Size, in bytes, of this PING frame. Calculated as:
-  // 8 (control frame header) + 4 (id)
-  const size_t kPingSize = 12;
-  SpdyFrameBuilder builder(PING, 0, protocol_version(), kPingSize);
+  SpdyFrameBuilder builder(PING, 0, protocol_version(), GetPingSize());
   builder.WriteUInt32(ping.id());
-  DCHECK_EQ(kPingSize, builder.length());
+  DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
 SpdyGoAwayControlFrame* SpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
     SpdyGoAwayStatus status) const {
   SpdyGoAwayIR goaway(last_accepted_stream_id, status);
   return reinterpret_cast<SpdyGoAwayControlFrame*>(SerializeGoAway(goaway));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeGoAway(
     const SpdyGoAwayIR& goaway) const {
-  // Size, in bytes, of this GOAWAY frame. Calculated as:
-  // 8 (control frame header) + 4 (last good stream id)
-  size_t size = 12;
-  // SPDY 3+ GOAWAY frames also contain a status.
-  if (protocol_version() >= 3) {
-    size += 4;
-  }
-  SpdyFrameBuilder builder(GOAWAY, 0, protocol_version(), size);
+  SpdyFrameBuilder builder(GOAWAY, 0, protocol_version(), GetGoAwaySize());
   builder.WriteUInt32(goaway.last_good_stream_id());
   if (protocol_version() >= 3) {
     builder.WriteUInt32(goaway.status());
   }
-  DCHECK_EQ(size, builder.length());
+  DCHECK_EQ(GetGoAwaySize(), builder.length());
   return builder.take();
 }
 
 SpdyHeadersControlFrame* SpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* header_block) {
   // Basically the same as CreateSynReply().
   DCHECK_EQ(0, flags & (!CONTROL_FLAG_FIN));
@@ skipping 13 matching lines @@
   return headers_frame.release();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeHeaders(
     const SpdyHeadersIR& headers) {
   uint8 flags = 0;
   if (headers.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
 
-  // The size, in bytes, of this frame not including the variable-length
-  // name-value block. Calculated as:
-  // 8 (control frame header) + 4 (stream ID)
-  size_t headers_size_before_name_value_block = 12;
-  // In SPDY 2, there were 2 unused bytes before payload.
-  if (protocol_version() < 3) {
-    headers_size_before_name_value_block += 2;
-  }
-
   // The size of this frame, including variable-length name-value block.
-  size_t size = headers_size_before_name_value_block
+  size_t size = GetHeadersMinimumSize()
       + GetSerializedLength(protocol_version(),
                             &(headers.name_value_block()));
 
   SpdyFrameBuilder builder(HEADERS, flags, protocol_version(), size);
   builder.WriteUInt32(headers.stream_id());
   if (protocol_version() < 3) {
     builder.WriteUInt16(0);  // Unused.
   }
-  DCHECK_EQ(headers_size_before_name_value_block, builder.length());
+  DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   SerializeNameValueBlock(&builder, headers);
   DCHECK_EQ(size, builder.length());
 
   return builder.take();
 }
 
 SpdyWindowUpdateControlFrame* SpdyFramer::CreateWindowUpdate(
     SpdyStreamId stream_id,
     uint32 delta_window_size) const {
   SpdyWindowUpdateIR window_update(stream_id, delta_window_size);
   return reinterpret_cast<SpdyWindowUpdateControlFrame*>(
       SerializeWindowUpdate(window_update));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeWindowUpdate(
     const SpdyWindowUpdateIR& window_update) const {
-  // Size, in bytes, of this WINDOW_UPDATE frame. Calculated as:
-  // 8 (control frame header) + 4 (stream id) + 4 (delta)
-  const size_t kWindowUpdateSize = 16;
-
   SpdyFrameBuilder builder(WINDOW_UPDATE,
                            kNoFlags,
                            protocol_version(),
-                           kWindowUpdateSize);
+                           GetWindowUpdateSize());
   builder.WriteUInt32(window_update.stream_id());
   builder.WriteUInt32(window_update.delta());
-  DCHECK_EQ(kWindowUpdateSize, builder.length());
+  DCHECK_EQ(GetWindowUpdateSize(), builder.length());
   return builder.take();
 }
 
 // TODO(hkhalil): Gut with SpdyCredential removal.
 SpdyCredentialControlFrame* SpdyFramer::CreateCredentialFrame(
     const SpdyCredential& credential) const {
   SpdyCredentialIR credential_ir(credential.slot);
   credential_ir.set_proof(credential.proof);
   for (std::vector<std::string>::const_iterator cert = credential.certs.begin();
        cert != credential.certs.end();
        ++cert) {
     credential_ir.AddCertificate(*cert);
   }
   return reinterpret_cast<SpdyCredentialControlFrame*>(
       SerializeCredential(credential_ir));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeCredential(
     const SpdyCredentialIR& credential) const {
-  size_t size = 8;  // Room for frame header.
-  size += 2;  // Room for slot.
+  size_t size = GetCredentialMinimumSize();
   size += 4 + credential.proof().length();  // Room for proof.
   for (SpdyCredentialIR::CertificateList::const_iterator it =
        credential.certificates()->begin();
        it != credential.certificates()->end();
        ++it) {
     size += 4 + it->length();  // Room for certificate.
   }
 
   SpdyFrameBuilder builder(CREDENTIAL, 0, protocol_version(), size);
   builder.WriteUInt16(credential.slot());
+  DCHECK_EQ(GetCredentialMinimumSize(), builder.length());
   builder.WriteStringPiece32(credential.proof());
   for (SpdyCredentialIR::CertificateList::const_iterator it =
        credential.certificates()->begin();
        it != credential.certificates()->end();
        ++it) {
     builder.WriteStringPiece32(*it);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
@@ skipping 338 matching lines @@
         reinterpret_cast<const SpdyControlFrame&>(frame);
     return control_frame.type() == SYN_STREAM ||
         control_frame.type() == SYN_REPLY ||
         control_frame.type() == HEADERS;
   }
 
   // We don't compress Data frames.
   return false;
 }
 
-size_t SpdyFramer::GetMinimumControlFrameSize(int version,
-                                              SpdyControlType type) {
-  switch (type) {
-    case SYN_STREAM:
-      return SpdySynStreamControlFrame::size();
-    case SYN_REPLY:
-      return SpdySynReplyControlFrame::size();
-    case RST_STREAM:
-      return SpdyRstStreamControlFrame::size();
-    case SETTINGS:
-      return SpdySettingsControlFrame::size();
-    case NOOP:
-      // Even though NOOP is no longer supported, we still correctly report its
-      // size so that it can be handled correctly as incoming data if
-      // implementations so desire.
-      return SpdyFrame::kHeaderSize;
-    case PING:
-      return SpdyPingControlFrame::size();
-    case GOAWAY:
-      if (version < 3) {
-        // SPDY 2 GOAWAY is smaller by 32 bits. Since
-        // SpdyGoAwayControlFrame::size() returns the size for SPDY 3, we adjust
-        // before returning here.
-        return SpdyGoAwayControlFrame::size() - 4;
-      } else {
-        return SpdyGoAwayControlFrame::size();
-      }
-    case HEADERS:
-      return SpdyHeadersControlFrame::size();
-    case WINDOW_UPDATE:
-      return SpdyWindowUpdateControlFrame::size();
-    case CREDENTIAL:
-      return SpdyCredentialControlFrame::size();
-    case NUM_CONTROL_FRAME_TYPES:
-      break;
-  }
-  LOG(ERROR) << "Unknown control frame type " << type;
-  return std::numeric_limits<size_t>::max();
-}
-
 /* static */
 SpdyStreamId SpdyFramer::GetControlFrameStreamId(
     const SpdyControlFrame* control_frame) {
   SpdyStreamId stream_id = kInvalidStream;
   if (control_frame != NULL) {
     switch (control_frame->type()) {
       case SYN_STREAM:
         stream_id = reinterpret_cast<const SpdySynStreamControlFrame*>(
             control_frame)->stream_id();
         break;
@@ skipping 49 matching lines @@
       builder->WriteString(it->first);
       builder->WriteString(it->second);
     } else {
       builder->WriteStringPiece32(it->first);
       builder->WriteStringPiece32(it->second);
     }
   }
 }
 
 }  // namespace net