SPDY cleanup: use ParseFrameType and SerializeFrameType

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 309 matching lines @@
     header_buffer_length_ += len;
     return true;
   }
 
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional) OVERRIDE {
     ++syn_frame_count_;
-    InitHeaderStreaming(SYN_STREAM, stream_id);
+    if (framer_.protocol_version() > SPDY3) {
+      InitHeaderStreaming(HEADERS, stream_id);
+    } else {
+      InitHeaderStreaming(SYN_STREAM, stream_id);
+    }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
     ++syn_reply_frame_count_;
-    InitHeaderStreaming(SYN_REPLY, stream_id);
+    if (framer_.protocol_version() > SPDY3) {
+      InitHeaderStreaming(HEADERS, stream_id);
+    } else {
+      InitHeaderStreaming(SYN_REPLY, stream_id);
+    }
     if (fin) {
       ++fin_flag_count_;
     }
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {
     ++fin_frame_count_;
   }
 
@@ skipping 103 matching lines @@
       size_t bytes_read =
           (rand() % min(input_remaining, kMaxReadSize)) + 1;
       size_t bytes_processed = framer_.ProcessInput(input_ptr, bytes_read);
       input_remaining -= bytes_processed;
       input_ptr += bytes_processed;
     }
   }
 
   void InitHeaderStreaming(SpdyFrameType header_control_type,
                            SpdyStreamId stream_id) {
-    DCHECK_GE(header_control_type, FIRST_CONTROL_TYPE);
-    DCHECK_LE(header_control_type, LAST_CONTROL_TYPE);
+    if (!SpdyConstants::IsValidFrameType(framer_.protocol_version(),
+        SpdyConstants::SerializeFrameType(framer_.protocol_version(),
+                                          header_control_type))) {
+      DLOG(FATAL) << "Attempted to init header streaming with "
+                  << "invalid control frame type: "
+                  << header_control_type;
+    }
     memset(header_buffer_.get(), 0, header_buffer_size_);
     header_buffer_length_ = 0;
     header_stream_id_ = stream_id;
     header_control_type_ = header_control_type;
     header_buffer_valid_ = true;
     DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
   }
 
   // Override the default buffer size (16K). Call before using the framer!
   void set_header_buffer_size(size_t header_buffer_size) {
@@ skipping 3836 matching lines @@
   EXPECT_STREQ("DATA",
                SpdyFramer::FrameTypeToString(DATA));
   EXPECT_STREQ("SYN_STREAM",
                SpdyFramer::FrameTypeToString(SYN_STREAM));
   EXPECT_STREQ("SYN_REPLY",
                SpdyFramer::FrameTypeToString(SYN_REPLY));
   EXPECT_STREQ("RST_STREAM",
                SpdyFramer::FrameTypeToString(RST_STREAM));
   EXPECT_STREQ("SETTINGS",
                SpdyFramer::FrameTypeToString(SETTINGS));
-  EXPECT_STREQ("NOOP",
-               SpdyFramer::FrameTypeToString(NOOP));
   EXPECT_STREQ("PING",
                SpdyFramer::FrameTypeToString(PING));
   EXPECT_STREQ("GOAWAY",
                SpdyFramer::FrameTypeToString(GOAWAY));
   EXPECT_STREQ("HEADERS",
                SpdyFramer::FrameTypeToString(HEADERS));
   EXPECT_STREQ("WINDOW_UPDATE",
                SpdyFramer::FrameTypeToString(WINDOW_UPDATE));
   EXPECT_STREQ("PUSH_PROMISE",
                SpdyFramer::FrameTypeToString(PUSH_PROMISE));
@@ skipping 1103 matching lines @@
   EXPECT_EQ(4u, framer.MapWeightToPriority(109));
   EXPECT_EQ(4u, framer.MapWeightToPriority(74));
   EXPECT_EQ(5u, framer.MapWeightToPriority(73));
   EXPECT_EQ(5u, framer.MapWeightToPriority(37));
   EXPECT_EQ(6u, framer.MapWeightToPriority(36));
   EXPECT_EQ(6u, framer.MapWeightToPriority(1));
   EXPECT_EQ(7u, framer.MapWeightToPriority(0));
 }
 
 }  // namespace net