[Cronet] Make delaying sending request headers explicit in bidirectional stream

net/http/bidirectional_stream.h

 // Copyright 2015 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_HTTP_BIDIRECTIONAL_STREAM_H_
 #define NET_HTTP_BIDIRECTIONAL_STREAM_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 32 matching lines @@
   class NET_EXPORT Delegate {
    public:
     Delegate();
 
     // Called when the stream is ready for writing and reading. This is called
     // at most once for the lifetime of a stream.
     // The delegate may call BidirectionalStream::ReadData to start reading,
     // or call BidirectionalStream::SendData to send data.
     // The delegate should not call BidirectionalStream::Cancel
     // during this callback.
-    virtual void OnStreamReady() = 0;
+    // |request_headers_sent| if true, request headers have been sent. If false,
+    // SendRequestHeaders() needs to be explicitly called.
+    virtual void OnStreamReady(bool request_headers_sent) = 0;
 
     // Called when headers are received. This is called at most once for the
     // lifetime of a stream.
     // The delegate may call BidirectionalStream::ReadData to start reading,
     // call BidirectionalStream::SendData to send data,
     // or call BidirectionalStream::Cancel to cancel the stream.
     virtual void OnHeadersReceived(const SpdyHeaderBlock& response_headers) = 0;
 
     // Called when a pending read is completed asynchronously.
     // |bytes_read| specifies how much data is read.
@@ skipping 23 matching lines @@
     virtual ~Delegate();
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Constructs a BidirectionalStream. |request_info| contains information about
   // the request, and must be non-NULL. |session| is the http network session
   // with which this request will be made. |delegate| must be non-NULL.
   // |session| and |delegate| must outlive |this|.
+  // |send_request_headers_automatically| if true, request headers will be sent
+  // automatically when stream is negotiated. If false, request headers will be
+  // sent only when SendRequestHeaders() is invoked or with
+  // next SendData/SendvData.
   BidirectionalStream(
       std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
       HttpNetworkSession* session,
-      bool disable_auto_flush,
+      bool send_request_headers_automatically,
       Delegate* delegate);
 
   // Constructor that accepts a Timer, which can be used in tests to control
   // the buffering of received data.
   BidirectionalStream(
       std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
       HttpNetworkSession* session,
-      bool disable_auto_flush,
+      bool send_request_headers_automatically,
       Delegate* delegate,
       std::unique_ptr<base::Timer> timer);
 
   // Cancels |stream_request_| or |stream_impl_| if applicable.
   // |this| should not be destroyed during Delegate::OnHeadersSent or
   // Delegate::OnDataSent.
   ~BidirectionalStream() override;
 
+  // Sends request headers to server.
+  // When |send_request_headers_automatically_| is
+  // false and OnStreamReady() is invoked with request_headers_sent = false,
+  // headers will be combined with next SendData/SendvData unless this
+  // method is called first, in which case headers will be sent separately
+  // without delay.
+  // (This method cannot be called when |send_request_headers_automatically_| is
+  // true nor when OnStreamReady() is invoked with request_headers_sent = true,
+  // since headers have been sent by the stream when stream is negotiated
+  // successfully.)
+  void SendRequestHeaders();
+
   // Reads at most |buf_len| bytes into |buf|. Returns the number of bytes read,
   // or ERR_IO_PENDING if the read is to be completed asynchronously, or an
   // error code if any error occurred. If returns 0, there is no more data to
   // read. This should not be called before Delegate::OnHeadersReceived is
   // invoked, and should not be called again unless it returns with number
   // greater than 0 or until Delegate::OnDataRead is invoked.
   int ReadData(IOBuffer* buf, int buf_len);
 
   // Sends data. This should not be called before Delegate::OnHeadersSent is
   // invoked, and should not be called again until Delegate::OnDataSent is
@@ skipping 27 matching lines @@
   // this stream, including the size of frame headers, before SSL encryption and
   // not including proxy overhead. Note that some SPDY frames such as pings are
   // not associated with any stream, and are not included in this value.
   int64_t GetTotalSentBytes() const;
 
   // TODO(xunjieli): Implement a method to do flow control and a method to ping
   // remote end point.
 
  private:
   // BidirectionalStreamImpl::Delegate implementation:
-  void OnStreamReady() override;
+  void OnStreamReady(bool request_headers_sent) override;
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override;
   void OnDataRead(int bytes_read) override;
   void OnDataSent() override;
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override;
   void OnFailed(int error) override;
 
   // HttpStreamRequest::Delegate implementation:
   void OnStreamReady(const SSLConfig& used_ssl_config,
                      const ProxyInfo& used_proxy_info,
                      HttpStream* stream) override;
@@ skipping 22 matching lines @@
                                   const ProxyInfo& used_proxy_info,
                                   HttpStream* stream) override;
   void OnQuicBroken() override;
 
   // BidirectionalStreamRequestInfo used when requesting the stream.
   std::unique_ptr<BidirectionalStreamRequestInfo> request_info_;
   const BoundNetLog net_log_;
 
   HttpNetworkSession* session_;
 
-  bool disable_auto_flush_;
+  bool send_request_headers_automatically_;
+  // Whether request headers have been sent, as indicated in OnStreamReady()
+  // callback.
+  bool request_headers_sent_;
+
   Delegate* const delegate_;
 
   // Timer used to buffer data received in short time-spans and send a single
   // read completion notification.
   std::unique_ptr<base::Timer> timer_;
   // HttpStreamRequest used to request a BidirectionalStreamImpl. This is NULL
   // if the request has been canceled or completed.
   std::unique_ptr<HttpStreamRequest> stream_request_;
   // The underlying BidirectioanlStreamImpl used for this stream. It is
   // non-NULL, if the |stream_request_| successfully finishes.
   std::unique_ptr<BidirectionalStreamImpl> stream_impl_;
 
   // Buffer used for reading.
   scoped_refptr<IOBuffer> read_buffer_;
   // List of buffers used for writing.
   std::vector<scoped_refptr<IOBuffer>> write_buffer_list_;
   // List of buffer length.
   std::vector<int> write_buffer_len_list_;
 
   DISALLOW_COPY_AND_ASSIGN(BidirectionalStream);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_BIDIRECTIONAL_STREAM_H_