SPDY & HPACK: Land recent internal changes (through 65328503)

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 38 matching lines @@
 }  // namespace test
 
 // A datastructure for holding a set of headers from a HEADERS, PUSH_PROMISE,
 // SYN_STREAM, or SYN_REPLY frame.
 typedef std::map<std::string, std::string> SpdyHeaderBlock;
 
 // A datastructure for holding the ID and flag fields for SETTINGS.
 // Conveniently handles converstion to/from wire format.
 class NET_EXPORT_PRIVATE SettingsFlagsAndId {
  public:
-  static SettingsFlagsAndId FromWireFormat(int version, uint32 wire);
+  static SettingsFlagsAndId FromWireFormat(SpdyMajorVersion version,
+                                           uint32 wire);
 
   SettingsFlagsAndId() : flags_(0), id_(0) {}
 
   // TODO(hkhalil): restrict to enums instead of free-form ints.
   SettingsFlagsAndId(uint8 flags, uint32 id);
 
-  uint32 GetWireFormat(int version) const;
+  uint32 GetWireFormat(SpdyMajorVersion version) const;
 
   uint32 id() const { return id_; }
   uint8 flags() const { return flags_; }
 
  private:
   static void ConvertFlagsAndIdForSpdy2(uint32* val);
 
   uint8 flags_;
   uint32 id_;
 };
@@ skipping 236 matching lines @@
   // Constant for invalid (or unknown) stream IDs.
   static const SpdyStreamId kInvalidStream;
 
   // The maximum size of header data chunks delivered to the framer visitor
   // through OnControlFrameHeaderData. (It is exposed here for unit test
   // purposes.)
   static const size_t kHeaderDataChunkMaxSize;
 
   // Serializes a SpdyHeaderBlock.
   static void WriteHeaderBlock(SpdyFrameBuilder* frame,
-                               const int spdy_version,
+                               const SpdyMajorVersion spdy_version,
                                const SpdyHeaderBlock* headers);
 
   // Retrieve serialized length of SpdyHeaderBlock.
   // TODO(hkhalil): Remove, or move to quic code.
-  static size_t GetSerializedLength(const int spdy_version,
-                                    const SpdyHeaderBlock* headers);
+  static size_t GetSerializedLength(
+      const SpdyMajorVersion spdy_version,
+      const SpdyHeaderBlock* headers);
 
   // Create a new Framer, provided a SPDY version.
   explicit SpdyFramer(SpdyMajorVersion version);
   virtual ~SpdyFramer();
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
   void set_visitor(SpdyFramerVisitorInterface* visitor) {
@@ skipping 24 matching lines @@
   // Given a buffer containing a decompressed header block in SPDY
   // serialized format, parse out a SpdyHeaderBlock, putting the results
   // in the given header block.
   // Returns number of bytes consumed if successfully parsed, 0 otherwise.
   size_t ParseHeaderBlockInBuffer(const char* header_data,
                                 size_t header_length,
                                 SpdyHeaderBlock* block) const;
 
   // Serialize a data frame.
   SpdySerializedFrame* SerializeData(const SpdyDataIR& data) const;
-  // Serializes just the data frame header, excluding actual data payload.
-  SpdySerializedFrame* SerializeDataFrameHeader(const SpdyDataIR& data) const;
+  // Serializes the data frame header and optionally padding length fields,
+  // excluding actual data payload and padding.
+  SpdySerializedFrame* SerializeDataFrameHeaderWithPaddingLengthField(
+      const SpdyDataIR& data) const;
 
   // Serializes a SYN_STREAM frame.
   SpdySerializedFrame* SerializeSynStream(const SpdySynStreamIR& syn_stream);
 
   // Serialize a SYN_REPLY SpdyFrame.
   SpdySerializedFrame* SerializeSynReply(const SpdySynReplyIR& syn_reply);
 
   SpdySerializedFrame* SerializeRstStream(
       const SpdyRstStreamIR& rst_stream) const;
 
@@ skipping 92 matching lines @@
 
   // 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;
 
+  // Returns the prefix length for the given frame type.
+  size_t GetPrefixLength(SpdyFrameType type) 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_; }
 
   bool probable_http_response() const { return probable_http_response_; }
 
   SpdyStreamId expect_continuation() const { return expect_continuation_; }
 
-  SpdyPriority GetLowestPriority() const { return spdy_version_ < 3 ? 3 : 7; }
+  SpdyPriority GetLowestPriority() const {
+    return spdy_version_ < SPDY3 ? 3 : 7;
+  }
+
   SpdyPriority GetHighestPriority() const { return 0; }
 
   // Deliver the given control frame's compressed headers block to the visitor
   // in decompressed form, in chunks. Returns true if the visitor has
   // accepted all of the chunks.
   bool IncrementallyDecompressControlFrameHeaderData(
       SpdyStreamId stream_id,
       const char* data,
       size_t len);
 
  protected:
+  // TODO(jgraettinger): Switch to test peer pattern.
   FRIEND_TEST_ALL_PREFIXES(SpdyFramerTest, BasicCompression);
   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, 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.
   friend class net::HttpNetworkTransactionTest;
   friend class net::HttpProxyClientSocketPoolTest;
   friend class net::SpdyHttpStreamTest;
   friend class net::SpdyNetworkTransactionTest;
   friend class net::SpdyProxyClientSocketTest;
   friend class net::SpdySessionTest;
   friend class net::SpdyStreamTest;
   friend class net::SpdyWebSocketStreamTest;
   friend class net::WebSocketJobTest;
@@ skipping 10 matching lines @@
   // 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);
+  size_t ProcessIgnoredControlFramePayload(/*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().
   void DeliverHpackBlockAsSpdy3Block();
 
   // Helpers for above internal breakouts from ProcessInput.
   void ProcessControlFrameHeader(uint16 control_frame_type_field);
   // Always passed exactly 1 setting's worth of data.
   bool ProcessSetting(const char* data);
 
   // Retrieve serialized length of SpdyHeaderBlock. If compression is enabled, a
   // maximum estimate is returned.
   size_t GetSerializedLength(const SpdyHeaderBlock& headers);
 
   // Get (and lazily initialize) the ZLib state.
   z_stream* GetHeaderCompressor();
   z_stream* GetHeaderDecompressor();
 
+  size_t GetNumberRequiredContinuationFrames(size_t size);
+
+  void WritePayloadWithContinuation(SpdyFrameBuilder* builder,
+                                    const std::string& hpack_encoding,
+                                    SpdyStreamId stream_id,
+                                    SpdyFrameType type);
+
  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
   // to the given maximum number of bytes, and update the buffer
@@ skipping 124 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_