[SPDY] Replace SpdyIOBuffer with new SpdyBuffer class

net/spdy/spdy_session.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_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/spdy/buffered_spdy_framer.h"
+#include "net/spdy/spdy_buffer.h"
 #include "net/spdy/spdy_credential_state.h"
 #include "net/spdy/spdy_header_block.h"
-#include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_write_queue.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "net/ssl/ssl_config_service.h"
 
 namespace net {
 
 // This is somewhat arbitrary and not really fixed, but it will always work
 // reasonably with ethernet. Chop the world into 2-packet chunks.  This is
@@ skipping 197 matching lines @@
   // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch
   // histogram because this function does more than verifying domain
   // authentication now.
   bool VerifyDomainAuthentication(const std::string& domain);
 
   // Pushes the given producer into the write queue for
   // |stream|. |stream| is guaranteed to be activated before the
   // producer is used to produce its frame.
   void EnqueueStreamWrite(SpdyStream* stream,
                           SpdyFrameType frame_type,
-                          scoped_ptr<SpdyFrameProducer> producer);
+                          scoped_ptr<SpdyBufferProducer> producer);
 
   // Creates and returns a SYN frame for |stream_id|.
   scoped_ptr<SpdyFrame> CreateSynStream(
       SpdyStreamId stream_id,
       RequestPriority priority,
       uint8 credential_slot,
       SpdyControlFlags flags,
       const SpdyHeaderBlock& headers);
 
   // Tries to create a CREDENTIAL frame. If successful, fills in
   // |credential_frame| and returns OK. Returns the error (guaranteed
   // to not be ERR_IO_PENDING) otherwise.
   int CreateCredentialFrame(const std::string& origin,
                             SSLClientCertType type,
                             const std::string& key,
                             const std::string& cert,
                             RequestPriority priority,
                             scoped_ptr<SpdyFrame>* credential_frame);
 
   // Creates and returns a HEADERS frame.
   scoped_ptr<SpdyFrame> CreateHeadersFrame(SpdyStreamId stream_id,
                                            const SpdyHeaderBlock& headers,
                                            SpdyControlFlags flags);
 
-  // Creates and returns a data frame. May return NULL if stalled by
-  // flow control.
-  scoped_ptr<SpdyFrame> CreateDataFrame(SpdyStreamId stream_id,
-                                        net::IOBuffer* data,
-                                        int len,
-                                        SpdyDataFlags flags);
+  // Creates and returns a SpdyBuffer holding a data frame with the
+  // given data. May return NULL if stalled by flow control.
+  scoped_ptr<SpdyBuffer> CreateDataBuffer(SpdyStreamId stream_id,
+                                          net::IOBuffer* data,
+                                          int len,
+                                          SpdyDataFlags flags);
 
   // Close a stream.
   void CloseStream(SpdyStreamId stream_id, int status);
 
   // Close a stream that has been created but is not yet active.
   void CloseCreatedStream(SpdyStream* stream, int status);
 
   // Reset a stream by sending a RST_STREAM frame with given status code.
   // Also closes the stream.  Was not piggybacked to CloseStream since not
   // all of the calls to CloseStream necessitate sending a RST_STREAM.
@@ skipping 287 matching lines @@
   // Pushes the given frame with the given priority into the write
   // queue for the session.
   void EnqueueSessionWrite(RequestPriority priority,
                            SpdyFrameType frame_type,
                            scoped_ptr<SpdyFrame> frame);
 
   // Puts |producer| associated with |stream| onto the write queue
   // with the given priority.
   void EnqueueWrite(RequestPriority priority,
                     SpdyFrameType frame_type,
-                    scoped_ptr<SpdyFrameProducer> producer,
+                    scoped_ptr<SpdyBufferProducer> producer,
                     const scoped_refptr<SpdyStream>& stream);
 
   // Track active streams in the active stream list.
   void ActivateStream(SpdyStream* stream);
   void DeleteStream(SpdyStreamId id, int status);
 
   // Removes this session from the session pool.
   void RemoveFromPool();
 
   // Check if we have a pending pushed-stream for this url
@@ skipping 166 matching lines @@
   // Map of all the streams that have already started to be pushed by the
   // server, but do not have consumers yet.
   PushedStreamMap unclaimed_pushed_streams_;
 
   // Set of all created streams but that have not yet sent any frames.
   CreatedStreamSet created_streams_;
 
   // The write queue.
   SpdyWriteQueue write_queue_;
 
-  // The packet we are currently sending.
-  bool write_pending_;            // Will be true when a write is in progress.
-  SpdyIOBuffer in_flight_write_;  // This is the write buffer in progress.
+  // Data for the frame we are currently sending.
+  // Whether we have a socket write pending completion.
+  bool write_pending_;
+  // The buffer we're currently writing.
+  scoped_ptr<SpdyBuffer> in_flight_write_;
+  // The type of the frame in |in_flight_write_|.
   SpdyFrameType in_flight_write_frame_type_;
+  // The size of the frame in |in_flight_write_|.
+  size_t in_flight_write_frame_size_;
+  // The stream to notify when |in_flight_write_| has been written to
+  // the socket completely.
+  scoped_refptr<SpdyStream> in_flight_write_stream_;
 
   // Flag if we have a pending message scheduled for WriteSocket.
   bool delayed_write_pending_;
 
   // Flag if we're using an SSL connection for this SpdySession.
   bool is_secure_;
 
   // Certificate error code when using a secure connection.
   int certificate_error_code_;
 
@@ skipping 111 matching lines @@
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
 
   TimeFunc time_func_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_