Remove SpdyFramerVisitorInterface::OnControlFrameHeaderData().

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 67 matching lines @@
 
 // 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:
 //   1. OnSynStream, OnSynReply, OnHeaders, or OnPushPromise is called.
-//   2. Repeated: OnControlFrameHeaderData is called with chunks of the
-//      decompressed header block. In each call the len parameter is greater
-//      than zero.
-//   3. OnControlFrameHeaderData is called with len set to zero, indicating
-//      that the full header block has been delivered for the control frame.
-// During step 2 the visitor may return false, indicating that the chunk of
-// header data could not be handled by the visitor (typically this indicates
-// resource exhaustion). If this occurs the framer will discontinue
-// delivering chunks to the visitor, set a SPDY_CONTROL_PAYLOAD_TOO_LARGE
-// error, and clean up appropriately. Note that this will cause the header
-// decompressor to lose synchronization with the sender's header compressor,
-// making the SPDY session unusable for future work. The visitor's OnError
-// function should deal with this condition by closing the SPDY connection.
 class NET_EXPORT_PRIVATE SpdyFramerVisitorInterface {
  public:
   virtual ~SpdyFramerVisitorInterface() {}
 
   // Called if an error is detected in the SpdySerializedFrame protocol.
   virtual void OnError(SpdyFramer* framer) = 0;
 
   // Called when the common header for a frame is received. Validating the
   // common header occurs in later processing.
   virtual void OnCommonHeader(SpdyStreamId stream_id,
@@ skipping 32 matching lines @@
   // and be returned for all header frames comprising a logical header block
   // (i.e. until OnHeaderFrameEnd() is called with end_headers == true).
   virtual SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) = 0;
 
   // Called after processing the payload of a frame containing header data.
   // |end_headers| is true if there will not be any subsequent CONTINUATION
   // frames.
   virtual void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) = 0;
 
-  // Called when a chunk of header data is available. This is called
-  // after OnSynStream, OnSynReply, OnHeaders(), or OnPushPromise.
-  // |stream_id| The stream receiving the header data.
-  // |header_data| A buffer containing the header data chunk received.
-  // |len| The length of the header data buffer. A length of zero indicates
-  //       that the header data block has been completely sent.
-  // When this function returns true the visitor indicates that it accepted
-  // all of the data. Returning false indicates that that an unrecoverable
-  // error has occurred, such as bad header data or resource exhaustion.
-  virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                        const char* header_data,
-                                        size_t len) = 0;
-
   // Called when a SYN_STREAM frame is received.
-  // Note that header block data is not included. See
-  // OnControlFrameHeaderData().
+  // Note that header block data is not included. See OnHeaderFrameStart().
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional) = 0;
 
   // Called when a SYN_REPLY frame is received.
-  // Note that header block data is not included. See
-  // OnControlFrameHeaderData().
+  // Note that header block data is not included. See OnHeaderFrameStart().
   virtual void OnSynReply(SpdyStreamId stream_id, bool fin) = 0;
 
   // Called when a RST_STREAM frame has been parsed.
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) = 0;
 
   // Called when a SETTINGS frame is received.
   // |clear_persisted| True if the respective flag is set on the SETTINGS frame.
   virtual void OnSettings(bool clear_persisted) {}
 
   // Called when a complete setting within a SETTINGS frame has been parsed and
   // validated.
   virtual void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) = 0;
 
   // Called when a SETTINGS frame is received with the ACK flag set.
   virtual void OnSettingsAck() {}
 
   // Called before and after parsing SETTINGS id and value tuples.
   virtual void OnSettingsEnd() = 0;
 
   // Called when a PING frame has been parsed.
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) = 0;
 
   // Called when a GOAWAY frame has been parsed.
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
                         SpdyGoAwayStatus status) = 0;
 
   // Called when a HEADERS frame is received.
-  // Note that header block data is not included. See
-  // OnControlFrameHeaderData().
+  // Note that header block data is not included. See OnHeaderFrameStart().
   // |stream_id| The stream receiving the header.
   // |has_priority| Whether or not the headers frame included a priority value,
   //     and, if protocol version == HTTP2, stream dependency info.
   // |weight| If |has_priority| is true, then weight (in the range [1, 256])
   //     for the receiving stream, otherwise 0.
   // |parent_stream_id| If |has_priority| is true and protocol
   //     version == HTTP2, the parent stream of the receiving stream, else 0.
   // |exclusive| If |has_priority| is true and protocol
   //     version == HTTP2, the exclusivity of dependence on the parent stream,
   //     else false.
@@ skipping 28 matching lines @@
   //       that the opaque data has been completely sent.
   // When this function returns true the visitor indicates that it accepted
   // all of the data. Returning false indicates that that an error has
   // occurred while processing the data. Default implementation returns true.
   virtual bool OnRstStreamFrameData(const char* rst_stream_data, size_t len);
 
   // Called when a BLOCKED frame has been parsed.
   virtual void OnBlocked(SpdyStreamId stream_id) {}
 
   // Called when a PUSH_PROMISE frame is received.
-  // Note that header block data is not included. See
-  // OnControlFrameHeaderData().
+  // Note that header block data is not included. See OnHeaderFrameStart().
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
                              bool end) = 0;
 
   // Called when a CONTINUATION frame is received.
-  // Note that header block data is not included. See
-  // OnControlFrameHeaderData().
+  // Note that header block data is not included. See OnHeaderFrameStart().
   virtual void OnContinuation(SpdyStreamId stream_id, bool end) = 0;
 
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(
       SpdyStreamId stream_id,
       base::StringPiece origin,
       const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {}
 
   // Called when a PRIORITY frame is received.
   // |stream_id| The stream to update the priority of.
@@ skipping 88 matching lines @@
   };
 
   // Typedef for a function used to create SpdyFramerDecoderAdapter's.
   // Defined in support of evaluating an alternate HTTP/2 decoder.
   typedef std::unique_ptr<SpdyFramerDecoderAdapter> (*DecoderAdapterFactoryFn)(
       SpdyFramer* outer);
 
   // 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.)
+  // The maximum size of header data decompressed/delivered at once to the
+  // header block parser. (Exposed here for unit test purposes.)
   static const size_t kHeaderDataChunkMaxSize;
 
   void SerializeHeaderBlockWithoutCompression(
       SpdyFrameBuilder* builder,
       const SpdyHeaderBlock& header_block) const;
 
   // Retrieve serialized length of SpdyHeaderBlock.
   // TODO(hkhalil): Remove, or move to quic code.
   static size_t GetSerializedLength(
       const SpdyMajorVersion spdy_version,
@@ skipping 322 matching lines @@
   // frame_type_field    : the unparsed frame type octet(s)
   // payload_length_field: the stated length in octets of the frame payload
   //
   // For valid frames, returns the correct SpdyFrameType.
   // Otherwise returns a best guess at invalid frame type,
   // after setting the appropriate SpdyError.
   SpdyFrameType ValidateFrameHeader(bool is_control_frame,
                                     int frame_type_field,
                                     size_t payload_length_field);
 
-  // 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().  |compressed_len| is used for
-  // logging compression percentage.
-  void DeliverHpackBlockAsSpdy3Block(size_t compressed_len);
-
   // Helpers for above internal breakouts from ProcessInput.
   void ProcessControlFrameHeader(int 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.
@@ skipping 164 matching lines @@
   bool end_stream_when_done_;
 
   // If true, then ProcessInput returns after processing a full frame,
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_