Remove already obsolete CREDENTIAL frame from SPDY code.

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.
 
 #include "net/spdy/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 219 matching lines @@
 size_t SpdyFramer::GetControlFrameHeaderSize() const {
   return SpdyConstants::GetControlFrameHeaderSize(protocol_version());
 }
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
   // header block.
   if (protocol_version() <= SPDY3) {
     // Calculated as:
     // control frame header + 2 * 4 (stream IDs) + 1 (priority)
-    // + 1 (unused, was credential slot)
+    // + 1 (unused)
     return GetControlFrameHeaderSize() + 10;
   } else {
     return GetControlFrameHeaderSize() +
         kPriorityDependencyPayloadSize +
         kPriorityWeightPayloadSize;
   }
 }
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
@@ skipping 239 matching lines @@
     case RST_STREAM_CANCEL:
       return "CANCEL";
     case RST_STREAM_INTERNAL_ERROR:
       return "INTERNAL_ERROR";
     case RST_STREAM_FLOW_CONTROL_ERROR:
       return "FLOW_CONTROL_ERROR";
     case RST_STREAM_STREAM_IN_USE:
       return "STREAM_IN_USE";
     case RST_STREAM_STREAM_ALREADY_CLOSED:
       return "STREAM_ALREADY_CLOSED";
-    case RST_STREAM_INVALID_CREDENTIALS:
-      return "INVALID_CREDENTIALS";
     case RST_STREAM_FRAME_TOO_LARGE:
       return "FRAME_TOO_LARGE";
     case RST_STREAM_CONNECT_ERROR:
       return "CONNECT_ERROR";
     case RST_STREAM_ENHANCE_YOUR_CALM:
       return "ENHANCE_YOUR_CALM";
     case RST_STREAM_INADEQUATE_SECURITY:
       return "INADEQUATE_SECURITY";
     case RST_STREAM_HTTP_1_1_REQUIRED:
       return "HTTP_1_1_REQUIRED";
@@ skipping 14 matching lines @@
     case SETTINGS:
       return "SETTINGS";
     case PING:
       return "PING";
     case GOAWAY:
       return "GOAWAY";
     case HEADERS:
       return "HEADERS";
     case WINDOW_UPDATE:
       return "WINDOW_UPDATE";
-    case CREDENTIAL:
-      return "CREDENTIAL";
     case PUSH_PROMISE:
       return "PUSH_PROMISE";
     case CONTINUATION:
       return "CONTINUATION";
     case PRIORITY:
       return "PRIORITY";
     case ALTSVC:
       return "ALTSVC";
     case BLOCKED:
       return "BLOCKED";
@@ skipping 335 matching lines @@
     ProcessControlFrameHeader(control_frame_type_field);
   }
 
   return original_len - len;
 }
 
 void SpdyFramer::ProcessControlFrameHeader(int control_frame_type_field) {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
   DCHECK_LE(GetControlFrameHeaderSize(), current_frame_buffer_.len());
 
-  // TODO(mlavan): Either remove credential frames from the code entirely,
-  // or add them to parsing + serialization methods for SPDY3.
-  // Early detection of deprecated frames that we ignore.
-  if (protocol_version() <= SPDY3) {
-    if (control_frame_type_field == CREDENTIAL) {
-      current_frame_type_ = CREDENTIAL;
-      DCHECK_EQ(SPDY3, protocol_version());
-      DVLOG(1) << "CREDENTIAL control frame found. Ignoring.";
-      CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
-      return;
-    }
-  }
-
   if (!SpdyConstants::IsValidFrameType(protocol_version(),
                                        control_frame_type_field)) {
     if (protocol_version() <= SPDY3) {
       DLOG(WARNING) << "Invalid control frame type " << control_frame_type_field
                     << " (protocol version: " << protocol_version() << ")";
       set_error(SPDY_INVALID_CONTROL_FRAME);
       return;
     } else {
       // In HTTP2 we ignore unknown frame types for extensibility, as long as
       // the rest of the control frame header is valid.
@@ skipping 541 matching lines @@
 
           SpdyPriority priority = 0;
           successful_read = reader.ReadUInt8(&priority);
           DCHECK(successful_read);
           if (protocol_version() <= SPDY2) {
             priority = priority >> 6;
           } else {
             priority = priority >> 5;
           }
 
-          // Seek past unused byte; used to be credential slot in SPDY 3.
+          // Seek past unused byte.
           reader.Seek(1);
 
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
           }
           visitor_->OnSynStream(
@@ skipping 892 matching lines @@
 
   // The size of this frame, including variable-length header block.
   size_t size = GetSynStreamMinimumSize() +
                 GetSerializedLength(syn_stream.header_block());
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
   builder.WriteUInt32(syn_stream.stream_id());
   builder.WriteUInt32(syn_stream.associated_to_stream_id());
   builder.WriteUInt8(priority << ((protocol_version() <= SPDY2) ? 6 : 5));
-  builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
+  builder.WriteUInt8(0);  // Unused byte.
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeHeaderBlock(&builder, syn_stream);
 
   if (debug_visitor_) {
     const size_t payload_len =
         GetSerializedLength(protocol_version(), &(syn_stream.header_block()));
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
                                           builder.length());
@@ skipping 849 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net