Implement padding PUSH_PROMISE and HEADERS frames.

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 318 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_READ_DATA_FRAME_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_ALTSVC_FRAME_PAYLOAD,
   };
@@ skipping 244 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameSizesAreValidated);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, HeaderCompression);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, DecompressUncompressedFrame);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ExpandBuffer_HeapSmash);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, HugeHeaderBlock);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, UnclosedStreamDataCompressors);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            UnclosedStreamDataCompressorsOneByteAtATime);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            UncompressLargerThanFrameBufferInitialSize);
+  FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
+                           CreatePushPromiseThenContinuationUncompressed);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ReadLargeSettingsFrame);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            ReadLargeSettingsFrameInSmallChunks);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameAtMaxSizeLimit);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, ControlFrameTooLarge);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            TooLargeHeadersFrameUsesContinuation);
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest,
                            TooLargePushPromiseFrameUsesContinuation);
   friend class net::HttpNetworkLayer;  // This is temporary for the server.
@@ skipping 13 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 ProcessDataFramePaddingLength(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);
   size_t ProcessAltSvcFramePayload(const char* data, size_t len);
   size_t ProcessIgnoredControlFramePayload(/*const char* data,*/ size_t len);
 
   // TODO(jgraettinger): To be removed with migration to
   // SpdyHeadersHandlerInterface.
@@ skipping 17 matching lines @@
 
   // Get (and lazily initialize) the HPACK state.
   HpackEncoder* GetHpackEncoder();
   HpackDecoder* GetHpackDecoder();
 
   size_t GetNumberRequiredContinuationFrames(size_t size);
 
   void WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                     const std::string& hpack_encoding,
                                     SpdyStreamId stream_id,
-                                    SpdyFrameType type);
+                                    SpdyFrameType type,
+                                    int padding_payload_len);
 
  private:
   // Deliver the given control frame's uncompressed headers block to the
   // visitor in chunks. Returns true if the visitor has accepted all of the
   // chunks.
   bool IncrementallyDeliverControlFrameHeaderData(SpdyStreamId stream_id,
                                                   const char* data,
                                                   size_t len);
 
   // Utility to copy the given data block to the current frame buffer, up
@@ skipping 130 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_