SPDY cleanup: remove credential slot.

net/spdy/buffered_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/buffered_spdy_framer.h"
 
 #include "base/logging.h"
 
 namespace net {
 
@@ skipping 44 matching lines @@
 }
 
 void BufferedSpdyFramer::OnError(SpdyFramer* spdy_framer) {
   DCHECK(spdy_framer);
   visitor_->OnError(spdy_framer->error_code());
 }
 
 void BufferedSpdyFramer::OnSynStream(SpdyStreamId stream_id,
                                      SpdyStreamId associated_stream_id,
                                      SpdyPriority priority,
-                                     uint8 credential_slot,
                                      bool fin,
                                      bool unidirectional) {
   frames_received_++;
   DCHECK(!control_frame_fields_.get());
   control_frame_fields_.reset(new ControlFrameFields());
   control_frame_fields_->type = SYN_STREAM;
   control_frame_fields_->stream_id = stream_id;
   control_frame_fields_->associated_stream_id = associated_stream_id;
   control_frame_fields_->priority = priority;
-  control_frame_fields_->credential_slot = credential_slot;
   control_frame_fields_->fin = fin;
   control_frame_fields_->unidirectional = unidirectional;
 
   InitHeaderStreaming(stream_id);
 }
 
 void BufferedSpdyFramer::OnHeaders(SpdyStreamId stream_id,
                                    bool fin) {
   frames_received_++;
   DCHECK(!control_frame_fields_.get());
@@ skipping 35 matching lines @@
       visitor_->OnStreamError(
           stream_id, "Could not parse Spdy Control Frame Header.");
       return false;
     }
     DCHECK(control_frame_fields_.get());
     switch (control_frame_fields_->type) {
       case SYN_STREAM:
         visitor_->OnSynStream(control_frame_fields_->stream_id,
                               control_frame_fields_->associated_stream_id,
                               control_frame_fields_->priority,
-                              control_frame_fields_->credential_slot,
                               control_frame_fields_->fin,
                               control_frame_fields_->unidirectional,
                               headers);
         break;
       case SYN_REPLY:
         visitor_->OnSynReply(control_frame_fields_->stream_id,
                              control_frame_fields_->fin,
                              headers);
         break;
       case HEADERS:
@@ skipping 97 matching lines @@
 bool BufferedSpdyFramer::HasError() {
   return spdy_framer_.HasError();
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdySynStreamIR).
 SpdyFrame* BufferedSpdyFramer::CreateSynStream(
     SpdyStreamId stream_id,
     SpdyStreamId associated_stream_id,
     SpdyPriority priority,
-    uint8 credential_slot,
     SpdyControlFlags flags,
     const SpdyHeaderBlock* headers) {
   SpdySynStreamIR syn_stream(stream_id);
   syn_stream.set_associated_to_stream_id(associated_stream_id);
   syn_stream.set_priority(priority);
-  syn_stream.set_slot(credential_slot);
   syn_stream.set_fin((flags & CONTROL_FLAG_FIN) != 0);
   syn_stream.set_unidirectional((flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
   // TODO(hkhalil): Avoid copy here.
   syn_stream.set_name_value_block(*headers);
   return spdy_framer_.SerializeSynStream(syn_stream);
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdySynReplyIR).
 SpdyFrame* BufferedSpdyFramer::CreateSynReply(
@@ skipping 84 matching lines @@
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   memset(header_buffer_, 0, kHeaderBufferSize);
   header_buffer_used_ = 0;
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net