[SPDY] Replace SpdyIOBuffer with new SpdyBuffer class

net/spdy/spdy_stream.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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/bandwidth_metrics.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_header_block.h"
@@ skipping 51 matching lines @@
     // Because a stream may have a SYN_* frame and multiple HEADERS frames,
     // this callback may be called multiple times.
     // |status| indicates network error. Returns network error code.
     virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                    base::Time response_time,
                                    int status) = 0;
 
     // Called when a HEADERS frame is sent.
     virtual void OnHeadersSent() = 0;
 
-    // Called when data is received.
-    // Returns network error code. OK when it successfully receives data.
-    virtual int OnDataReceived(const char* data, int length) = 0;
+    // Called when data is received. |buffer| may be NULL, which
+    // signals EOF.  Must return OK if the data was received
+    // successfully, or a network error code otherwise.
+    virtual int OnDataReceived(scoped_ptr<SpdyBuffer> buffer) = 0;
 
     // Called when data is sent.
     virtual void OnDataSent(size_t bytes_sent) = 0;
 
     // Called when SpdyStream is closed. No other delegate functions
     // will be called after this is called, and the delegate must not
     // access the stream after this is called.
     virtual void OnClose(int status) = 0;
 
    protected:
@@ skipping 112 matching lines @@
   // Called by the SpdySession when response data has been received for this
   // stream.  This callback may be called multiple times as data arrives
   // from the network, and will never be called prior to OnResponseReceived.
   //
   // |buffer| contains the data received, or NULL if the stream is
   //          being closed.  The stream must copy any data from this
   //          buffer before returning from this callback.
   //
   // |length| is the number of bytes received (at most 2^24 - 1) or 0 if
   //          the stream is being closed.
-  void OnDataReceived(const char* buffer, size_t length);
+  void OnDataReceived(scoped_ptr<SpdyBuffer> buffer);
 
   // Called by the SpdySession when a frame has been successfully and
   // completely written. |frame_size| is the total size of the frame
   // in bytes, including framing overhead.
   void OnFrameWriteComplete(SpdyFrameType frame_type, size_t frame_size);
 
   // Called by the SpdySession when the request is finished.  This callback
   // will always be called at the end of the request and signals to the
   // stream that the stream has no more network events.  No further callbacks
   // to the stream will be made after this call.
@@ skipping 50 matching lines @@
   // Returns true if the URL for this stream is known.
   bool HasUrl() const;
 
   // Get the URL associated with this stream.  Only valid when has_url() is
   // true.
   GURL GetUrl() const;
 
   int GetProtocolVersion() const;
 
  private:
-  class SynStreamFrameProducer;
-  class HeaderFrameProducer;
+  class SynStreamBufferProducer;
+  class HeaderBufferProducer;
 
   enum State {
     STATE_NONE,
     STATE_GET_DOMAIN_BOUND_CERT,
     STATE_GET_DOMAIN_BOUND_CERT_COMPLETE,
     STATE_SEND_DOMAIN_BOUND_CERT,
     STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE,
     STATE_SEND_HEADERS,
     STATE_SEND_HEADERS_COMPLETE,
     STATE_SEND_BODY,
@@ skipping 100 matching lines @@
   base::TimeTicks send_time_;
   base::TimeTicks recv_first_byte_time_;
   base::TimeTicks recv_last_byte_time_;
 
   // Number of data bytes that have been sent/received on this stream, not
   // including frame overhead. Note that this does not count headers.
   int send_bytes_;
   int recv_bytes_;
 
   // Data received before delegate is attached.
-  std::vector<scoped_refptr<IOBufferWithSize> > pending_buffers_;
+  ScopedVector<SpdyBuffer> pending_buffers_;
 
   SSLClientCertType domain_bound_cert_type_;
   std::string domain_bound_private_key_;
   std::string domain_bound_cert_;
   ServerBoundCertService::RequestHandle domain_bound_cert_request_handle_;
 
   // When OnFrameWriteComplete() is called, these variables are set.
   SpdyFrameType just_completed_frame_type_;
   size_t just_completed_frame_size_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_