Clean up max_frame_size related constants, move storage of setting to the framer.

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 501 matching lines @@
   // Used only in log messages.
   void set_display_protocol(const std::string& protocol) {
     display_protocol_ = protocol;
   }
 
   void set_max_decode_buffer_size_bytes(size_t max_decode_buffer_size_bytes) {
     GetHpackDecoder()->set_max_decode_buffer_size_bytes(
         max_decode_buffer_size_bytes);
   }
 
+  size_t send_frame_size_limit() const { return send_frame_size_limit_; }
+
+  void set_send_frame_size_limit(size_t send_frame_size_limit) {
+    send_frame_size_limit_ = send_frame_size_limit;
+  }
+
   void set_recv_frame_size_limit(size_t recv_frame_size_limit) {
     recv_frame_size_limit_ = recv_frame_size_limit;
   }
 
   void SetDecoderHeaderTableDebugVisitor(
       std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor);
 
   void SetEncoderHeaderTableDebugVisitor(
       std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor);
 
@@ skipping 200 matching lines @@
   // frame header size (SYN_STREAM) is sufficient; all remaining control
   // frame data is streamed to the visitor.
   static const size_t kControlFrameBufferSize;
 
   // The maximum size of the control frames that we send, including the size of
   // the header. This limit is arbitrary. We can enforce it here or at the
   // application layer. We chose the framing layer, but this can be changed (or
   // removed) if necessary later down the line.
   // TODO(diannahu): Rename to make it clear that this limit is for sending.
   static const size_t kMaxControlFrameSize;
+  // The maximum size for the payload of DATA frames to send.
+  static const size_t kMaxDataPayloadSendSize;
 
   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 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_;
 
-  // The limit on HTTP/2 payload size as specified in the
-  // SETTINGS_MAX_FRAME_SIZE advertised to peer
+  // The limit on the size of sent HTTP/2 payloads as specified in the
+  // SETTINGS_MAX_FRAME_SIZE received from peer.
+  size_t send_frame_size_limit_ = kSpdyInitialFrameSizeLimit;
+
+  // The limit on the size of received HTTP/2 payloads as specified in the
+  // SETTINGS_MAX_FRAME_SIZE advertised to peer.
   size_t recv_frame_size_limit_ = kSpdyInitialFrameSizeLimit;
 
   CharBuffer current_frame_buffer_;
 
   // The type of the frame currently being read.
   SpdyFrameType current_frame_type_;
 
   // The total length of the frame currently being read, including frame header.
   uint32_t current_frame_length_;
 
@@ skipping 65 matching lines @@
   // rather than reading all available input.
   bool process_single_input_frame_ = false;
 
   bool enforce_max_frame_size_ =
       FLAGS_chromium_http2_flag_enforce_max_frame_size;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_