Land recent SPDY changes (through 70021377)

net/spdy/spdy_framer.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <list>
 #include <map>
 #include <memory>
@@ skipping 266 matching lines @@
   // OnControlFrameHeaderData().
   virtual void OnContinuation(SpdyStreamId stream_id, bool end) = 0;
 
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(SpdyStreamId stream_id,
                         uint32 max_age,
                         uint16 port,
                         base::StringPiece protocol_id,
                         base::StringPiece host,
                         base::StringPiece origin) {}
+
+  // Called when a PRIORITY frame is received.
+  virtual void OnPriority(SpdyStreamId stream_id,
+                          SpdyStreamId parent_stream_id,
+                          uint8 weight,
+                          bool exclusive) {};
 };
 
 // Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
 // SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
 // order to extract debug/internal information about the SpdyFramer as it
 // operates.
 //
 // Most SPDY implementations need not bother with this interface at all.
 class NET_EXPORT_PRIVATE SpdyFramerDebugVisitorInterface {
  public:
@@ skipping 174 matching lines @@
   // TODO(jgraettinger): This implementation is incorrect. The continuation
   // frame continues a previously-begun HPACK encoding; it doesn't begin a
   // new one. Figure out whether it makes sense to keep SerializeContinuation().
   SpdySerializedFrame* SerializeContinuation(
       const SpdyContinuationIR& continuation);
 
   // Serializes an ALTSVC frame. The ALTSVC frame advertises the
   // availability of an alternative service to the client.
   SpdySerializedFrame* SerializeAltSvc(const SpdyAltSvcIR& altsvc);
 
+  // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
+  // the relative priority of the given stream.
+  SpdySerializedFrame* SerializePriority(const SpdyPriorityIR& priority);
+
   // Serialize a frame of unknown type.
   SpdySerializedFrame* SerializeFrame(const SpdyFrameIR& frame);
 
   // NOTES about frame compression.
   // We want spdy to compress headers across the entire session.  As long as
   // the session is over TCP, frames are sent serially.  The client & server
   // can each compress frames in the same order and then compress them in that
   // order, and the remote can do the reverse.  However, we ultimately want
   // the creation of frames to be less sensitive to order so that they can be
   // placed over a UDP based protocol and yet still benefit from some
@@ skipping 228 matching lines @@
   SpdyError error_code_;
 
   // Note that for DATA frame, remaining_data_length_ is sum of lengths of
   // frame header, padding length field (optional), data payload (optional) and
   // padding payload (optional).
   size_t remaining_data_length_;
 
   // The length (in bytes) of the padding payload to be processed.
   size_t remaining_padding_payload_length_;
 
-  // The length (in bytes) of the padding length field to be processed.
-  size_t remaining_padding_length_fields_;
-
   // The number of bytes remaining to read from the current control frame's
   // headers. Note that header data blocks (for control types that have them)
   // are part of the frame's payload, and not the frame's headers.
   size_t remaining_control_header_;
 
   scoped_ptr<char[]> current_frame_buffer_;
   // Number of bytes read into the current_frame_buffer_.
   size_t current_frame_buffer_length_;
 
   // The type of the frame currently being read.
@@ skipping 55 matching lines @@
   // If a HEADERS frame is followed by a CONTINUATION frame, the FIN/END_STREAM
   // flag is still carried in the HEADERS frame. If it's set, flip this so that
   // we know to terminate the stream when the entire header block has been
   // processed.
   bool end_stream_when_done_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_