Add an async ReadTrailers 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 21 matching lines @@
 // are owned by the QuicClientSession which created them.
 class NET_EXPORT_PRIVATE QuicChromiumClientStream : public QuicSpdyStream {
  public:
   // TODO(rch): Remove this class completely in favor of async methods
   // 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 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 19 matching lines @@
 
     // 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);
 
+    // Reads trailing 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 ReadTrailingHeaders(SpdyHeaderBlock* header_block,
+                            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 52 matching lines @@
 
    private:
     friend class QuicChromiumClientStream;
 
     // Constucts a new Handle for |stream| with |delegate| set to receive
     // up calls on various events.
     Handle(QuicChromiumClientStream* stream, Delegate* delegate);
 
     // Methods invoked by the stream.
     void OnInitialHeadersAvailable();
-    void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers,
-                                    size_t frame_len);
+    void OnTrailingHeadersAvailable();
     void OnDataAvailable();
     void OnCanWrite();
     void OnClose();
     void OnError(int error);
 
     // Saves various fields from the stream before the stream goes away.
     void SaveState();
 
     QuicChromiumClientStream* stream_;  // Unowned.
     Delegate* delegate_;                // Owns this.
@@ skipping 84 matching lines @@
   // concurrent streams within the session to also not migrate.
   void DisableConnectionMigration();
 
   bool can_migrate() { return can_migrate_; }
 
   // True if this stream is the first data stream created on this session.
   bool IsFirstStream();
 
   bool DeliverInitialHeaders(SpdyHeaderBlock* header_block, int* frame_len);
 
+  bool DeliverTrailingHeaders(SpdyHeaderBlock* header_block, int* frame_len);
+
   using QuicSpdyStream::HasBufferedData;
   using QuicStream::sequencer;
 
  private:
   void NotifyHandleOfInitialHeadersAvailableLater();
   void NotifyHandleOfInitialHeadersAvailable();
-  void NotifyHandleOfTrailingHeadersAvailableLater(SpdyHeaderBlock headers,
-                                                   size_t frame_len);
-  void NotifyHandleOfTrailingHeadersAvailable(SpdyHeaderBlock headers,
-                                              size_t frame_len);
+  void NotifyHandleOfTrailingHeadersAvailableLater();
+  void NotifyHandleOfTrailingHeadersAvailable();
   void NotifyHandleOfDataAvailableLater();
   void NotifyHandleOfDataAvailable();
 
   NetLogWithSource net_log_;
   Handle* handle_;
 
   bool headers_delivered_;
 
   // True when initial headers have been sent.
   bool initial_headers_sent_;
 
   QuicClientSessionBase* session_;
 
   // Set to false if this stream to not be migrated during connection migration.
   bool can_migrate_;
 
   // Stores the initial header if they arrive before the delegate.
   SpdyHeaderBlock initial_headers_;
   // Length of the HEADERS frame containing initial headers.
   size_t initial_headers_frame_len_;
 
+  // Length of the HEADERS frame containing trailing headers.
+  size_t trailing_headers_frame_len_;
+
   base::WeakPtrFactory<QuicChromiumClientStream> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_STREAM_H_