Accept and ignore PRIORITY frames in SPDY4+.

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.
 
 #include "net/spdy/spdy_framer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 287 matching lines @@
   return GetControlFrameHeaderSize();
 }
 
 size_t SpdyFramer::GetPushPromiseMinimumSize() const {
   DCHECK_LT(SPDY3, protocol_version());
   // Size, in bytes, of a PUSH_PROMISE frame, sans the embedded header block.
   // Calculated as frame prefix + 4 (promised stream id).
   return GetControlFrameHeaderSize() + 4;
 }
 
-size_t SpdyFramer::GetContinuationMinimumSize() const  {
+size_t SpdyFramer::GetContinuationMinimumSize() const {
   // Size, in bytes, of a CONTINUATION frame not including the variable-length
   // headers fragments.
   return GetControlFrameHeaderSize();
 }
 
-size_t SpdyFramer::GetAltSvcMinimumSize() const  {
+size_t SpdyFramer::GetAltSvcMinimumSize() const {
   // Size, in bytes, of an ALTSVC frame not including the Protocol-ID, Host, and
   // (optional) Origin fields, all of which can vary in length.
   // Note that this gives a lower bound on the frame size rather than a true
   // minimum; the actual frame should always be larger than this.
   // Calculated as frame prefix + 4 (max-age) + 2 (port) + 1 (reserved byte)
   // + 1 (pid_len) + 1 (host_len).
   return GetControlFrameHeaderSize() + 9;
 }
 
+size_t SpdyFramer::GetPrioritySize() const {
+  // Size, in bytes, of a PRIORITY frame.
+  // Calculated as frame prefix + 4 (stream dependency) + 1 (weight)
+  return GetControlFrameHeaderSize() + 5;
+}
+
 size_t SpdyFramer::GetFrameMinimumSize() const {
   return std::min(GetDataFrameMinimumSize(), GetControlFrameHeaderSize());
 }
 
 size_t SpdyFramer::GetFrameMaximumSize() const {
   return SpdyConstants::GetFrameMaximumSize(protocol_version());
 }
 
 size_t SpdyFramer::GetDataFrameMaximumPayload() const {
   return GetFrameMaximumSize() - GetDataFrameMinimumSize();
@@ skipping 137 matching lines @@
     case CREDENTIAL:
       return "CREDENTIAL";
     case BLOCKED:
       return "BLOCKED";
     case PUSH_PROMISE:
       return "PUSH_PROMISE";
     case CONTINUATION:
       return "CONTINUATION";
     case ALTSVC:
       return "ALTSVC";
+    case PRIORITY:
+      return "PRIORITY";
   }
   return "UNKNOWN_CONTROL_TYPE";
 }
 
 size_t SpdyFramer::ProcessInput(const char* data, size_t len) {
   DCHECK(visitor_);
   DCHECK(data);
 
   size_t original_len = len;
   do {
@@ skipping 471 matching lines @@
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
     case ALTSVC:
       if (current_frame_length_ <= GetAltSvcMinimumSize()) {
         set_error(SPDY_INVALID_CONTROL_FRAME);
       } else if (current_frame_flags_ != 0) {
         set_error(SPDY_INVALID_CONTROL_FRAME_FLAGS);
       }
       break;
+    case PRIORITY:
+      if (current_frame_length_ != GetPrioritySize() ||
+          protocol_version() <= SPDY3) {
+        set_error(SPDY_INVALID_CONTROL_FRAME);
+      } else if (current_frame_flags_ != 0) {
+        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
       // check above. However, we DLOG(FATAL) here in an effort to painfully
       // club the head of the developer who failed to keep this file in sync
       // with spdy_protocol.h.
       DLOG(FATAL);
       set_error(SPDY_INVALID_CONTROL_FRAME);
@@ skipping 759 matching lines @@
           visitor_->OnWindowUpdate(current_frame_stream_id_,
                                    delta_window_size);
         }
         break;
       case BLOCKED: {
           DCHECK_LT(SPDY3, protocol_version());
           DCHECK(reader.IsDoneReading());
           visitor_->OnBlocked(current_frame_stream_id_);
         }
         break;
+      case PRIORITY: {
+          DCHECK_LT(SPDY3, protocol_version());
+          // TODO(hkhalil): Process PRIORITY frames rather than ignore them.
+          reader.Seek(5);
+          DCHECK(reader.IsDoneReading());
+        }
+        break;
       default:
         // Unreachable.
         LOG(FATAL) << "Unhandled control frame " << current_frame_type_;
     }
 
     CHANGE_STATE(SPDY_IGNORE_REMAINING_PAYLOAD);
   }
   return original_len - len;
 }
 
@@ skipping 1426 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