Introduce new SpdyConstants class

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 670 matching lines @@
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     successful_read = reader->ReadUInt31(&current_frame_stream_id_);
     DCHECK(successful_read);
 
     remaining_data_length_ = current_frame_length_ - reader->GetBytesConsumed();
 
     // Before we accept a DATA frame, we need to make sure we're not in the
     // middle of processing a header block.
-    if (expect_continuation_ != 0 && control_frame_type_field != CONTINUATION) {
-      DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
-                  << "frame, but instead received frame type "
-                  << current_frame_type_;
-      set_error(SPDY_UNEXPECTED_FRAME);
-      return original_len - len;
-    } else if (control_frame_type_field == CONTINUATION &&
-               expect_continuation_ == 0) {
-      DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
+    const bool is_continuation_frame = (control_frame_type_field ==
+        SpdyConstants::SerializeFrameType(protocol_version(), CONTINUATION));
+    if ((expect_continuation_ != 0) != is_continuation_frame) {
+      if (expect_continuation_ != 0) {
+        DLOG(ERROR) << "The framer was expecting to receive a CONTINUATION "
+                    << "frame, but instead received frame type "
+                    << control_frame_type_field;
+      } else {
+        DLOG(ERROR) << "The framer received an unexpected CONTINUATION frame.";
+      }
       set_error(SPDY_UNEXPECTED_FRAME);
       return original_len - len;
     }
   }
   DCHECK_EQ(is_control_frame ? GetControlFrameHeaderSize()
                              : GetDataFrameMinimumSize(),
             reader->GetBytesConsumed());
   DCHECK_EQ(current_frame_length_,
             remaining_data_length_ + reader->GetBytesConsumed());
 
@@ skipping 55 matching lines @@
     ProcessControlFrameHeader(control_frame_type_field);
   }
 
   return original_len - len;
 }
 
 void SpdyFramer::ProcessControlFrameHeader(uint16 control_frame_type_field) {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
   DCHECK_LE(GetControlFrameHeaderSize(), current_frame_buffer_length_);
 
-  if (control_frame_type_field < FIRST_CONTROL_TYPE ||
-      control_frame_type_field > LAST_CONTROL_TYPE) {
+  // Early detection of deprecated frames that we ignore.
+  if (protocol_version() < SPDY4) {
+    if (control_frame_type_field == NOOP) {
+      current_frame_type_ = NOOP;
+      DVLOG(1) << "NOOP control frame found. Ignoring.";
+      CHANGE_STATE(SPDY_AUTO_RESET);
+      return;
+    }
+
+    if (control_frame_type_field == CREDENTIAL) {
+      current_frame_type_ = CREDENTIAL;
+      DCHECK_EQ(3, 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)) {
+    DLOG(WARNING) << "Invalid control frame type " << control_frame_type_field
+                  << " (protocol version: " << protocol_version() << ")";
     set_error(SPDY_INVALID_CONTROL_FRAME);
     return;
   }
 
-  current_frame_type_ = static_cast<SpdyFrameType>(control_frame_type_field);
-
-  if (current_frame_type_ == NOOP) {
-    DVLOG(1) << "NOOP control frame found. Ignoring.";
-    CHANGE_STATE(SPDY_AUTO_RESET);
-    return;
-  }
-
-  if (current_frame_type_ == CREDENTIAL) {
-    DCHECK_EQ(3, protocol_version());
-    DVLOG(1) << "CREDENTIAL control frame found. Ignoring.";
-    CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
-    return;
-  }
+  current_frame_type_ = SpdyConstants::ParseFrameType(protocol_version(),
+                                                      control_frame_type_field);
 
   // Do some sanity checking on the control frame sizes and flags.
   switch (current_frame_type_) {
     case SYN_STREAM:
-      DCHECK_GT(4, spdy_version_);
       if (current_frame_length_ < GetSynStreamMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ &
                  ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case SYN_REPLY:
       if (current_frame_length_ < GetSynReplyMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 102 matching lines @@
       if (current_frame_length_ < GetPushPromiseMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (spdy_version_ < 4 && current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       } else if (spdy_version_ >= 4 && current_frame_flags_ &
                  ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case CONTINUATION:
-      if (current_frame_length_ < GetContinuationMinimumSize() ||
-          protocol_version() < 4) {
+      if (current_frame_length_ < GetContinuationMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ & ~HEADERS_FLAG_END_HEADERS) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     default:
       LOG(WARNING) << "Valid " << display_protocol_
                    << " control frame with unhandled type: "
                    << current_frame_type_;
       // This branch should be unreachable because of the frame type bounds
@@ skipping 1901 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