Add an async ReadInitialHeaders 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 initial headers are available.
-    virtual void OnInitialHeadersAvailable(const SpdyHeaderBlock& headers,
-                                           size_t frame_len) = 0;
-
     // 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:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Wrapper for interacting with the session in a restricted fashion.
   class NET_EXPORT_PRIVATE Handle {
    public:
     ~Handle();
 
     // Returns true if the stream is still connected.
     bool IsOpen() { return stream_ != nullptr; }
 
+    // Reads initial headers into |header_block| and returns the lenght of

[xunjieli, 2017/05/10 17:54:27]

nit: typo in length

[Ryan Hamilton, 2017/05/10 18:26:40]

Done.

+    // the HEADERS frame which contained them. If headers are not available,
+    // returns ERR_IO_PENDING and will invokes |callback| asynchronously when

[xunjieli, 2017/05/10 17:54:27]

nit: s/invokes/invoke

[Ryan Hamilton, 2017/05/10 18:26:40]

Done.

+    // 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);
+
     // 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 51 matching lines @@
     Delegate* GetDelegate();
 
    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(const SpdyHeaderBlock& headers,
-                                   size_t frame_len);
+    void OnInitialHeadersAvailable();
     void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers,
                                     size_t frame_len);
     void OnDataAvailable();
     void OnClose();
     void OnError(int error);
 
     // Saves various fields from the stream before the stream goes away.
     void SaveState();
 
+    void SetCallback(CompletionCallback new_callback,
+                     CompletionCallback* callback);
+
     QuicChromiumClientStream* stream_;  // Unowned.
     Delegate* delegate_;                // Owns this.
 
+    // True when callbacks can be invoked, which means no synchronous
+    // method is in progress.
+    bool can_invoke_callbacks_;
+    CompletionCallback read_headers_callback_;
+    SpdyHeaderBlock* read_headers_buffer_;
+
     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 58 matching lines @@
 
   // Prevents this stream from migrating to a new network. May cause other
   // 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);
+
   using QuicSpdyStream::HasBufferedData;
   using QuicStream::sequencer;
 
  private:
-  void NotifyHandleOfInitialHeadersAvailableLater(SpdyHeaderBlock headers,
-                                                  size_t frame_len);
-  void NotifyHandleOfInitialHeadersAvailable(SpdyHeaderBlock headers,
-                                             size_t frame_len);
+  void NotifyHandleOfInitialHeadersAvailableLater();
+  void NotifyHandleOfInitialHeadersAvailable();
   void NotifyHandleOfTrailingHeadersAvailableLater(SpdyHeaderBlock headers,
                                                    size_t frame_len);
   void NotifyHandleOfTrailingHeadersAvailable(SpdyHeaderBlock headers,
                                               size_t frame_len);
   void NotifyHandleOfDataAvailableLater();
   void NotifyHandleOfDataAvailable();
 
   NetLogWithSource net_log_;
   Handle* handle_;
 
@@ skipping 17 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_