Land recent SPDY changes

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 <string>
@@ skipping 67 matching lines @@
 // SettingsMap has unique (flags, value) pair for given SpdySettingsIds ID.
 typedef std::pair<SpdySettingsFlags, uint32> SettingsFlagsAndValue;
 typedef std::map<SpdySettingsIds, SettingsFlagsAndValue> SettingsMap;
 
 // Scratch space necessary for processing SETTINGS frames.
 struct NET_EXPORT_PRIVATE SpdySettingsScratch {
   SpdySettingsScratch() { Reset(); }
 
   void Reset() {
     setting_buf_len = 0;
-    last_setting_id = 0;
+    last_setting_id = -1;
   }
 
   // Buffer contains up to one complete key/value pair.
   char setting_buf[8];
 
   // The amount of the buffer that is filled with valid data.
   size_t setting_buf_len;
 
   // The ID of the last setting that was processed in the current SETTINGS
   // frame. Used for detecting out-of-order or duplicate keys within a settings
-  // frame. Set to 0 before first key/value pair is processed.
-  uint32 last_setting_id;
+  // frame. Set to -1 before first key/value pair is processed.
+  int last_setting_id;
 };
 
 // SpdyFramerVisitorInterface is a set of callbacks for the SpdyFramer.
 // Implement this interface to receive event callbacks as frames are
 // decoded from the framer.
 //
 // Control frames that contain SPDY header blocks (SYN_STREAM, SYN_REPLY,
 // HEADER, and PUSH_PROMISE) are processed in fashion that allows the
 // decompressed header block to be delivered in chunks to the visitor.
 // The following steps are followed:
@@ skipping 163 matching lines @@
  public:
   // SPDY states.
   // TODO(mbelshe): Can we move these into the implementation
   //                and avoid exposing through the header.  (Needed for test)
   enum SpdyState {
     SPDY_ERROR,
     SPDY_RESET,
     SPDY_AUTO_RESET,
     SPDY_READING_COMMON_HEADER,
     SPDY_CONTROL_FRAME_PAYLOAD,
+    SPDY_READ_PADDING_LENGTH,
+    SPDY_CONSUME_PADDING,
     SPDY_IGNORE_REMAINING_PAYLOAD,
     SPDY_FORWARD_STREAM_FRAME,
     SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK,
     SPDY_CONTROL_FRAME_HEADER_BLOCK,
     SPDY_GOAWAY_FRAME_PAYLOAD,
     SPDY_RST_STREAM_FRAME_PAYLOAD,
     SPDY_SETTINGS_FRAME_PAYLOAD,
   };
 
   // SPDY error codes.
@@ skipping 176 matching lines @@
   size_t GetBlockedSize() const;
   size_t GetPushPromiseMinimumSize() const;
   size_t GetContinuationMinimumSize() const;
 
   // Returns the minimum size a frame can be (data or control).
   size_t GetFrameMinimumSize() const;
 
   // Returns the maximum size a frame can be (data or control).
   size_t GetFrameMaximumSize() const;
 
+  // Returns the maximum size that a control frame can be.
+  size_t GetControlFrameMaximumSize() const;
+
   // Returns the maximum payload size of a DATA frame.
   size_t GetDataFrameMaximumPayload() const;
 
   // For debugging.
   static const char* StateToString(int state);
   static const char* ErrorCodeToString(int error_code);
   static const char* StatusCodeToString(int status_code);
   static const char* FrameTypeToString(SpdyFrameType type);
 
   SpdyMajorVersion protocol_version() const { return spdy_version_; }
@@ skipping 47 matching lines @@
   // consumed from the data.
   size_t ProcessCommonHeader(const char* data, size_t len);
   size_t ProcessControlFramePayload(const char* data, size_t len);
   size_t ProcessControlFrameBeforeHeaderBlock(const char* data, size_t len);
   // HPACK data is re-encoded as SPDY3 and re-entrantly delivered through
   // |ProcessControlFrameHeaderBlock()|. |is_hpack_header_block| controls
   // whether data is treated as HPACK- vs SPDY3-encoded.
   size_t ProcessControlFrameHeaderBlock(const char* data,
                                         size_t len,
                                         bool is_hpack_header_block);
+  size_t ProcessFramePaddingLength(const char* data, size_t len);
+  size_t ProcessFramePadding(const char* data, size_t len);
   size_t ProcessDataFramePayload(const char* data, size_t len);
   size_t ProcessGoAwayFramePayload(const char* data, size_t len);
   size_t ProcessRstStreamFramePayload(const char* data, size_t len);
   size_t ProcessSettingsFramePayload(const char* data, size_t len);
 
   // TODO(jgraettinger): To be removed with migration to
   // SpdyHeadersHandlerInterface.
   // Serializes the last-processed header block of |hpack_decoder_| as
   // a SPDY3 format block, and delivers it to the visitor via reentrant
   // call to ProcessControlFrameHeaderBlock().
@@ skipping 64 matching lines @@
 
   // The size of the control frame buffer.
   // Since this is only used for control frame headers, the maximum control
   // frame header size (SYN_STREAM) is sufficient; all remaining control
   // frame data is streamed to the visitor.
   static const size_t kControlFrameBufferSize;
 
   SpdyState state_;
   SpdyState previous_state_;
   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 53 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_