SPDY cleanup: remove credential slot.

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 165 matching lines @@
   }
   LOG(DFATAL) << "Unhandled SPDY version.";
   return 0;
 }
 
 size_t SpdyFramer::GetSynStreamMinimumSize() const {
   // Size, in bytes, of a SYN_STREAM frame not including the variable-length
   // name-value block.
   if (spdy_version_ < 4) {
     // Calculated as:
-    // control frame header + 2 * 4 (stream IDs) + 1 (priority) + 1 (slot)
+    // control frame header + 2 * 4 (stream IDs) + 1 (priority)
+    // + 1 (unused, was credential slot)
     return GetControlFrameHeaderSize() + 10;
   } else {
     // Calculated as:
     // frame prefix + 4 (priority)
     return GetControlFrameHeaderSize() + 4;
   }
 }
 
 size_t SpdyFramer::GetSynReplyMinimumSize() const {
   // Size, in bytes, of a SYN_REPLY frame not including the variable-length
@@ skipping 958 matching lines @@
 
           SpdyPriority priority = 0;
           successful_read = reader.ReadUInt8(&priority);
           DCHECK(successful_read);
           if (protocol_version() < 3) {
             priority = priority >> 6;
           } else {
             priority = priority >> 5;
           }
 
-          uint8 slot = 0;
-          if (protocol_version() < 3) {
-            // SPDY 2 had an unused byte here. Seek past it.
-            reader.Seek(1);
-          } else {
-            successful_read = reader.ReadUInt8(&slot);
-            DCHECK(successful_read);
-          }
+         // Seek past unused byte; used to be credential slot in SPDY 3.
+         reader.Seek(1);
 
           DCHECK(reader.IsDoneReading());
           if (debug_visitor_) {
             debug_visitor_->OnReceiveCompressedFrame(
                 current_frame_stream_id_,
                 current_frame_type_,
                 current_frame_length_);
           }
           visitor_->OnSynStream(
               current_frame_stream_id_,
               associated_to_stream_id,
               priority,
-              slot,
               (current_frame_flags_ & CONTROL_FLAG_FIN) != 0,
               (current_frame_flags_ & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case SETTINGS:
         visitor_->OnSettings(current_frame_flags_ &
                              SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS);
         CHANGE_STATE(SPDY_SETTINGS_FRAME_PAYLOAD);
         break;
@@ skipping 41 matching lines @@
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
           } else if (spdy_version_ > 3 &&
               current_frame_flags_ & HEADERS_FLAG_PRIORITY) {
             // SPDY 4+ is missing SYN_STREAM. Simulate it so that API changes
             // can be made independent of wire changes.
             visitor_->OnSynStream(
                 current_frame_stream_id_,
                 0,  // associated_to_stream_id
                 priority,
-                0,  // TODO(hkhalil): handle slot for SPDY 4+?
                 current_frame_flags_ & CONTROL_FLAG_FIN,
                 false);  // unidirectional
           } else {
             visitor_->OnHeaders(
                 current_frame_stream_id_,
                 (current_frame_flags_ & CONTROL_FLAG_FIN) != 0);
           }
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
@@ skipping 533 matching lines @@
   // The size of this frame, including variable-length name-value block.
   const size_t size = GetSynStreamMinimumSize()
       + GetSerializedLength(syn_stream.name_value_block());
 
   SpdyFrameBuilder builder(size);
   if (spdy_version_ < 4) {
     builder.WriteControlFrameHeader(*this, SYN_STREAM, flags);
     builder.WriteUInt32(syn_stream.stream_id());
     builder.WriteUInt32(syn_stream.associated_to_stream_id());
     builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
-    builder.WriteUInt8(syn_stream.slot());
+    builder.WriteUInt8(0);  // Unused byte where credential slot used to be.
   } else {
     builder.WriteFramePrefix(*this,
                              HEADERS,
                              flags,
                              syn_stream.stream_id());
     builder.WriteUInt32(priority);
   }
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_stream);
 
@@ skipping 566 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net