Add an async ReadBody method to QuicChromiumClientStream::Handle

net/quic/chromium/quic_chromium_client_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.
 //
 // NOTE: This code is not shared between Google and Chrome.
 
 #ifndef NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_STREAM_H_
 #define NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_STREAM_H_
 
 #include <stddef.h>
@@ skipping 25 matching lines @@
   // on the Handle.
   // Delegate handles protocol specific behavior of a quic stream.
   class NET_EXPORT_PRIVATE Delegate {
    public:
     Delegate() {}
 
     // Called when trailing headers are available.
     virtual void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers,
                                             size_t frame_len) = 0;
 
-    // Called when data is available to be read.
-    virtual void OnDataAvailable() = 0;
-
     // Called when the stream is closed by the peer.
     virtual void OnClose() = 0;
 
     // Called when the stream is closed because of an error.
     virtual void OnError(int error) = 0;
 
    protected:
     virtual ~Delegate() {}
 
    private:
@@ skipping 10 matching lines @@
 
     // Reads initial headers into |header_block| and returns the length of
     // the HEADERS frame which contained them. If headers are not available,
     // returns ERR_IO_PENDING and will invoke |callback| asynchronously when
     // the headers arrive.
     // TODO(rch): Invoke |callback| when there is a stream or connection error
     // instead of calling OnClose() or OnError().
     int ReadInitialHeaders(SpdyHeaderBlock* header_block,
                            const CompletionCallback& callback);
 
+    // Reads at most |buffer_len| bytes of body into |buffer| and returns the
+    // number of bytes read. If body is not available, returns ERR_IO_PENDING
+    // and will invoke |callback| asynchronously when data arrive.
+    // TODO(rch): Invoke |callback| when there is a stream or connection error
+    // instead of calling OnClose() or OnError().
+    int ReadBody(IOBuffer* buffer,
+                 int buffer_len,
+                 const CompletionCallback& callback);
+
     // Writes |header_block| to the peer. Closes the write side if |fin| is
     // true. If non-null, |ack_notifier_delegate| will be notified when the
     // headers are ACK'd by the peer.
     size_t WriteHeaders(SpdyHeaderBlock header_block,
                         bool fin,
                         QuicReferenceCountedPointer<QuicAckListenerInterface>
                             ack_notifier_delegate);
 
     // Writes |data| to the peer. Closes the write side if |fin| is true.
     // If the data could not be written immediately, returns ERR_IO_PENDING
@@ skipping 67 matching lines @@
 
     // Saves various fields from the stream before the stream goes away.
     void SaveState();
 
     QuicChromiumClientStream* stream_;  // Unowned.
     Delegate* delegate_;                // Owns this.
 
     CompletionCallback read_headers_callback_;
     SpdyHeaderBlock* read_headers_buffer_;
 
+    CompletionCallback read_body_callback_;
+    IOBuffer* read_body_buffer_;
+    int read_body_buffer_len_;
+
     QuicStreamId id_;
     QuicErrorCode connection_error_;
     QuicRstStreamErrorCode stream_error_;
     bool fin_sent_;
     bool fin_received_;
     uint64_t stream_bytes_read_;
     uint64_t stream_bytes_written_;
     bool is_done_reading_;
     bool is_first_stream_;
     size_t num_bytes_consumed_;
@@ skipping 103 matching lines @@
   size_t initial_headers_frame_len_;
 
   base::WeakPtrFactory<QuicChromiumClientStream> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_STREAM_H_