Remove SpdySynReplyControlFrame and SpdyGoAwayControlFrame.

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 653 matching lines @@
 
   // Determine the frame size without variable-length data.
   int32 frame_size_without_variable_data;
   switch (current_control_frame.type()) {
     case SYN_STREAM:
       syn_frame_processed_ = true;
       frame_size_without_variable_data = SpdySynStreamControlFrame::size();
       break;
     case SYN_REPLY:
       syn_frame_processed_ = true;
-      frame_size_without_variable_data = SpdySynReplyControlFrame::size();
-      // SPDY 2 had two bytes of unused space preceeding payload.
-      if (spdy_version_ < 3) {
-        frame_size_without_variable_data += 2;
-      }
+      frame_size_without_variable_data = GetSynReplyMinimumSize();
       break;
     case HEADERS:
       frame_size_without_variable_data = SpdyHeadersControlFrame::size();
       // SPDY 2 had two bytes of unused space preceeding payload.
       if (spdy_version_ < 3) {
         frame_size_without_variable_data += 2;
       }
       break;
     case SETTINGS:
       frame_size_without_variable_data = SpdySettingsControlFrame::size();
@@ skipping 274 matching lines @@
               syn_stream_frame->associated_stream_id(),
               syn_stream_frame->priority(),
               syn_stream_frame->credential_slot(),
               (syn_stream_frame->flags() & CONTROL_FLAG_FIN) != 0,
               (syn_stream_frame->flags() & CONTROL_FLAG_UNIDIRECTIONAL) != 0);
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case SYN_REPLY:
         {
-          SpdySynReplyControlFrame* syn_reply_frame =
-              reinterpret_cast<SpdySynReplyControlFrame*>(&control_frame);
-          visitor_->OnSynReply(
-              syn_reply_frame->stream_id(),
-              (syn_reply_frame->flags() & CONTROL_FLAG_FIN) != 0);
+          SpdyFrameReader reader(current_frame_buffer_.get(),
+                                 current_frame_len_);
+          reader.Seek(4);  // Seek past control bit, type and version.
+          uint8 flags;
+          bool successful_read = reader.ReadUInt8(&flags);
+          DCHECK(successful_read);
+          reader.Seek(3);  // Seek past length.
+          SpdyStreamId stream_id = kInvalidStream;
+          successful_read = reader.ReadUInt31(&stream_id);
+          DCHECK(successful_read);
+          if (protocol_version() < 3) {
+            // SPDY 2 had two unused bytes here. Seek past them.
+            reader.Seek(2);
+          }
+          DCHECK(reader.IsDoneReading());
+          visitor_->OnSynReply(stream_id, (flags & CONTROL_FLAG_FIN) != 0);
         }
         CHANGE_STATE(SPDY_CONTROL_FRAME_HEADER_BLOCK);
         break;
       case HEADERS:
         {
           SpdyHeadersControlFrame* headers_frame =
               reinterpret_cast<SpdyHeadersControlFrame*>(&control_frame);
           visitor_->OnHeaders(
               headers_frame->stream_id(),
               (headers_frame->flags() & CONTROL_FLAG_FIN) != 0);
@@ skipping 199 matching lines @@
           }
           break;
         case RST_STREAM: {
             SpdyRstStreamControlFrame* rst_stream_frame =
                 reinterpret_cast<SpdyRstStreamControlFrame*>(&control_frame);
             visitor_->OnRstStream(rst_stream_frame->stream_id(),
                                   rst_stream_frame->status());
           }
           break;
         case GOAWAY: {
-            SpdyGoAwayControlFrame* go_away_frame =
-                reinterpret_cast<SpdyGoAwayControlFrame*>(&control_frame);
-            if (spdy_version_ < 3) {
-              visitor_->OnGoAway(go_away_frame->last_accepted_stream_id(),
-                                 GOAWAY_OK);
-            } else {
-              visitor_->OnGoAway(go_away_frame->last_accepted_stream_id(),
-                                 go_away_frame->status());
+            SpdyFrameReader reader(current_frame_buffer_.get(),
+                                   current_frame_len_);
+            reader.Seek(GetControlFrameMinimumSize());  // Skip frame header.
+            SpdyStreamId last_accepted_stream_id = kInvalidStream;
+            bool successful_read = reader.ReadUInt32(&last_accepted_stream_id);
+            DCHECK(successful_read);
+            SpdyGoAwayStatus status = GOAWAY_OK;
+            if (spdy_version_ >= 3) {
+              uint32 status_raw = GOAWAY_OK;
+              successful_read = reader.ReadUInt32(&status_raw);
+              DCHECK(successful_read);
+              if (status_raw > static_cast<uint32>(GOAWAY_INVALID) &&
+                  status_raw < static_cast<uint32>(GOAWAY_NUM_STATUS_CODES)) {
+                status = static_cast<SpdyGoAwayStatus>(status_raw);
+              } else {
+                // TODO(hkhalil): Probably best to OnError here, depending on
+                // our interpretation of the spec. Keeping with existing liberal
+                // behavior for now.
+              }
             }
+            DCHECK(reader.IsDoneReading());
+            visitor_->OnGoAway(last_accepted_stream_id, status);
           }
           break;
         default:
           // Unreachable.
           LOG(FATAL) << "Unhandled control frame " << control_frame.type();
       }
 
       CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
     }
   }
@@ skipping 211 matching lines @@
     priority = GetLowestPriority();
   }
   builder.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
   builder.WriteUInt8(syn_stream.slot());
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_stream);
 
   return builder.take();
 }
 
-SpdySynReplyControlFrame* SpdyFramer::CreateSynReply(
+SpdyFrame* SpdyFramer::CreateSynReply(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   DCHECK_EQ(0, flags & ~CONTROL_FLAG_FIN);
 
   SpdySynReplyIR syn_reply(stream_id);
   syn_reply.set_fin(flags & CONTROL_FLAG_FIN);
   // TODO(hkhalil): Avoid copy here.
   *(syn_reply.GetMutableNameValueBlock()) = *headers;
 
-  scoped_ptr<SpdySynReplyControlFrame> reply_frame(
-      reinterpret_cast<SpdySynReplyControlFrame*>(SerializeSynReply(
-          syn_reply)));
+  scoped_ptr<SpdyControlFrame> reply_frame(
+      reinterpret_cast<SpdyControlFrame*>(SerializeSynReply(syn_reply)));
   if (compressed) {
-    return reinterpret_cast<SpdySynReplyControlFrame*>(
-        CompressControlFrame(*reply_frame.get(), headers));
+    return CompressControlFrame(*reply_frame.get(), headers);
   }
   return reply_frame.release();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynReply(
     const SpdySynReplyIR& syn_reply) {
   uint8 flags = 0;
   if (syn_reply.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
@@ skipping 87 matching lines @@
   return reinterpret_cast<SpdyPingControlFrame*>(SerializePing(ping));
 }
 
 SpdySerializedFrame* SpdyFramer::SerializePing(const SpdyPingIR& ping) const {
   SpdyFrameBuilder builder(PING, 0, protocol_version(), GetPingSize());
   builder.WriteUInt32(ping.id());
   DCHECK_EQ(GetPingSize(), builder.length());
   return builder.take();
 }
 
-SpdyGoAwayControlFrame* SpdyFramer::CreateGoAway(
+SpdyFrame* SpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
     SpdyGoAwayStatus status) const {
   SpdyGoAwayIR goaway(last_accepted_stream_id, status);
-  return reinterpret_cast<SpdyGoAwayControlFrame*>(SerializeGoAway(goaway));
+  return SerializeGoAway(goaway);
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeGoAway(
     const SpdyGoAwayIR& goaway) const {
   SpdyFrameBuilder builder(GOAWAY, 0, protocol_version(), GetGoAwaySize());
   builder.WriteUInt32(goaway.last_good_stream_id());
   if (protocol_version() >= 3) {
     builder.WriteUInt32(goaway.status());
   }
   DCHECK_EQ(GetGoAwaySize(), builder.length());
@@ skipping 207 matching lines @@
           const SpdySynStreamControlFrame& syn_frame =
               reinterpret_cast<const SpdySynStreamControlFrame&>(frame);
           frame_size = SpdySynStreamControlFrame::size();
           *payload_length = syn_frame.header_block_len();
           *header_length = frame_size;
           *payload = frame.data() + *header_length;
         }
         break;
       case SYN_REPLY:
         {
-          const SpdySynReplyControlFrame& syn_frame =
-              reinterpret_cast<const SpdySynReplyControlFrame&>(frame);
-          frame_size = SpdySynReplyControlFrame::size();
-          *payload_length = syn_frame.header_block_len();
-          *header_length = frame_size;
+          *header_length = GetSynReplyMinimumSize();
+          *payload_length = frame.length() -
+              (*header_length - GetControlFrameMinimumSize());
           *payload = frame.data() + *header_length;
-          // SPDY 2 had two bytes of unused space preceeding payload.
-          if (spdy_version_ < 3) {
-            *header_length += 2;
-            *payload += 2;
-          }
         }
         break;
       case HEADERS:
         {
           const SpdyHeadersControlFrame& headers_frame =
               reinterpret_cast<const SpdyHeadersControlFrame&>(frame);
           frame_size = SpdyHeadersControlFrame::size();
           *payload_length = headers_frame.header_block_len();
           *header_length = frame_size;
           *payload = frame.data() + *header_length;
@@ skipping 234 matching lines @@
       builder->WriteString(it->first);
       builder->WriteString(it->second);
     } else {
       builder->WriteStringPiece32(it->first);
       builder->WriteStringPiece32(it->second);
     }
   }
 }
 
 }  // namespace net