Remove QuicChromiumClientStream::Delegate in favor of async methods.

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 14 matching lines @@
 #include "net/quic/platform/api/quic_string_piece.h"
 
 namespace net {
 
 class QuicClientSessionBase;
 
 // A client-initiated ReliableQuicStream.  Instances of this class
 // 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 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 length of
     // the HEADERS frame which contained them. If headers are not available,
@@ skipping 18 matching lines @@
     // 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);
+    int WriteHeaders(SpdyHeaderBlock header_block,

[xunjieli, 2017/05/31 00:25:22]

Could you add a comment here mentioning that the return value is a net error
code?

[Ryan Hamilton, 2017/05/31 02:49:56]

Done.

+                     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
     // and invokes |callback| asynchronously when the write completes.
     int WriteStreamData(base::StringPiece data,
                         bool fin,
                         const CompletionCallback& callback);
 
     // Same as WriteStreamData except it writes data from a vector of IOBuffers,
     // with the length of each buffer at the corresponding index in |lengths|.
@@ skipping 12 matching lines @@
     // Prevents the connection from migrating to a new network while this
     // stream is open.
     void DisableConnectionMigration();
 
     // Sets the priority of the stream to |priority|.
     void SetPriority(SpdyPriority priority);
 
     // Sends a RST_STREAM frame to the peer and closes the streams.
     void Reset(QuicRstStreamErrorCode error_code);
 
-    // Clears |delegate_| from this Handle, but does not disconnect the Handle
-    // from |stream_|.
-    void ClearDelegate();
-
     QuicStreamId id() const;
     QuicErrorCode connection_error() const;
     QuicRstStreamErrorCode stream_error() const;
     bool fin_sent() const;
     bool fin_received() const;
     uint64_t stream_bytes_read() const;
     uint64_t stream_bytes_written() const;
     size_t NumBytesConsumed() const;
     bool IsDoneReading() const;
     bool IsFirstStream() const;
 
     // TODO(rch): Move these test-only methods to a peer, or else remove.
     void OnPromiseHeaderList(QuicStreamId promised_id,
                              size_t frame_len,
                              const QuicHeaderList& header_list);
     SpdyPriority priority() const;
     bool can_migrate();
 
-    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);
+    // Constucts a new Handle for |stream|.
+    explicit Handle(QuicChromiumClientStream* stream);
 
     // Methods invoked by the stream.
     void OnInitialHeadersAvailable();
     void OnTrailingHeadersAvailable();
     void OnDataAvailable();
     void OnCanWrite();
     void OnClose();
     void OnError(int error);
 
+    // Invokes async IO callbacks because of |error|.
+    void InvokeCallbacksOnError(int error);
+
     // Saves various fields from the stream before the stream goes away.
     void SaveState();
 
+    void SetCallback(CompletionCallback new_callback,
+                     CompletionCallback* callback);
+
+    void ResetAndRun(CompletionCallback* callback, int rv);
+
+    int HandleIOComplete(int rv);
+
     QuicChromiumClientStream* stream_;  // Unowned.
-    Delegate* delegate_;                // Owns this.
+
+    bool may_invoke_callbacks_;  // True when callbacks may be invoked.
 
     // Callback to be invoked when ReadHeaders completes asynchronously.
     CompletionCallback read_headers_callback_;
     SpdyHeaderBlock* read_headers_buffer_;
 
     // Callback to be invoked when ReadBody completes asynchronously.
     CompletionCallback read_body_callback_;
     IOBuffer* read_body_buffer_;
     int read_body_buffer_len_;
 
     // Callback to be invoked when WriteStreamData or WritevStreamData completes
     // asynchronously.
     CompletionCallback write_callback_;
 
     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_;
     SpdyPriority priority_;
 
+    int net_error_;
+
+    base::WeakPtrFactory<Handle> weak_factory_;
+
     DISALLOW_COPY_AND_ASSIGN(Handle);
   };
 
   QuicChromiumClientStream(QuicStreamId id,
                            QuicClientSessionBase* session,
                            const NetLogWithSource& net_log);
 
   ~QuicChromiumClientStream() override;
 
   // QuicSpdyStream
@@ skipping 22 matching lines @@
   // Writes |data| to the peer and closes the write side if |fin| is true.
   // Returns true if the data have been fully written. If the data was not fully
   // written, returns false and OnCanWrite() will be invoked later.
   bool WriteStreamData(QuicStringPiece data, bool fin);
   // Same as WriteStreamData except it writes data from a vector of IOBuffers,
   // with the length of each buffer at the corresponding index in |lengths|.
   bool WritevStreamData(const std::vector<scoped_refptr<IOBuffer>>& buffers,
                         const std::vector<int>& lengths,
                         bool fin);
 
-  // Creates a new Handle for this stream and sets |delegate| on the handle.
-  // Must only be called once.
-  std::unique_ptr<QuicChromiumClientStream::Handle> CreateHandle(
-      QuicChromiumClientStream::Delegate* delegate);
+  // Creates a new Handle for this stream. Must only be called once.
+  std::unique_ptr<QuicChromiumClientStream::Handle> CreateHandle();
 
   // Clears |handle_| from this stream.
   void ClearHandle();
 
   void OnError(int error);
 
   // Reads at most |buf_len| bytes into |buf|. Returns the number of bytes read.
   int Read(IOBuffer* buf, int buf_len);
 
   const NetLogWithSource& net_log() const { return net_log_; }
@@ skipping 28 matching lines @@
   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.
+  // Stores the initial header if they arrive before the handle.
   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_