Added a net::BidirectionalStream to expose a bidirectional streaming interface

net/http/bidirectional_stream.h

Index: net/http/bidirectional_stream.h
diff --git a/net/http/bidirectional_stream.h b/net/http/bidirectional_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..768290add2b207490a718f11d23aa832ada7001f
--- /dev/null
+++ b/net/http/bidirectional_stream.h
@@ -0,0 +1,161 @@
+// 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 "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/request_priority.h"
+#include "net/http/bidirectional_stream_job.h"
+#include "net/http/http_stream_factory.h"
+#include "net/ssl/ssl_config.h"
+
+namespace net {
+
+class BoundNetLog;
+class HttpAuthController;
+class HttpNetworkSession;
+class HttpStream;
+class HttpStreamRequest;
+class IOBuffer;
+class ProxyInfo;
+class SpdyHeaderBlock;
+
+// A class to do HTTP/2 bidirectional streaming. Note that only one
+// ReadData or SendData should be in flight until the operation completes
+// synchronously or asynchronously. The BidirectionalStream must be torn down
+// before the HttpNetworkSession.
+class NET_EXPORT BidirectionalStream : public BidirectionalStreamJob::Delegate,
+                                       public HttpStreamRequest::Delegate {
+ public:
+  // Delegate interface to get notified of success of failure. Callbacks will be
+  // invoked asynchronously.
+  // TODO(xunjieli): Surface the protocol negotiated.
+  class NET_EXPORT Delegate {
+   public:
+    Delegate() {}
+
+    // Called when the request headers have been sent.
+    virtual void OnRequestHeadersSent() = 0;
+
+    // Called when response headers are received.
+    // The delegate should call BidirectionalStream::ReadData to start reading
+    // or call BidirectionalStream::Cancel to cancel the stream.
+    virtual void OnHeaders(const SpdyHeaderBlock& response_headers) = 0;
+
+    // Called when read is completed asynchronously. |bytes_read| specifies how
+    // much data is available.
+    // The delegate should call BidirectionalStream::ReadData to continue
+    // reading or call BidirectionalStream::Cancel to cancel the stream.
+    virtual void OnReadCompleted(int bytes_read) = 0;
+
+    // Called when the entire buffer passed through SendData is sent.
+    virtual void OnDataSent() = 0;
+
+    // Called when trailers are received.
+    // No other delegate functions will be called after this.

[mef, 2015/12/02 16:36:01]

I don't think this is correct statement. I think we've said  that OnTrailers
will be called when trailers frame arrives, not after completion of all reads
and writes.

[xunjieli, 2015/12/02 19:18:51]

Good catch. Will do.

+    virtual void OnTrailers(const SpdyHeaderBlock& trailers) = 0;
+
+    // Called when the stream is closed or an error occurred.
+    // No other delegate functions will be called after this.
+    virtual void OnFailed(int error) = 0;

[mef, 2015/12/02 16:36:01]

I think we need either OnClose, or OnSucceeded to indicate successful close of
the stream.

[xunjieli, 2015/12/02 19:18:51]

I'd like to understand why OnClose/OnSucceeded is absolutely necessary. Even if
the server half closes earlier than the client, the client will still be able to
know either through onFailed (if an error occurred), or if ReadData returns 0
synchronously (everything goes well).

+
+   protected:
+    virtual ~Delegate() {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Delegate);
+  };
+
+  struct NET_EXPORT RequestInfo {
+    RequestInfo();
+    ~RequestInfo();
+
+    // The requested URL.
+    GURL url;
+
+    // The method to use (GET, POST, etc.).
+    std::string method;
+
+    // Any extra request headers (including User-Agent).
+    HttpRequestHeaders extra_headers;
+  };
+
+  BidirectionalStream(const RequestInfo& request_info,
+                      RequestPriority priority,
+                      HttpNetworkSession* session,
+                      Delegate* delegate);
+
+  // Destroys the helper and cancels any pending request.
+  ~BidirectionalStream() override;
+
+  // 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.
+  // There should not be called again unless it IO completes synchronously or
+  // until OnReadCompleted is invoked.
+  int ReadData(IOBuffer* buf, int buf_len);
+
+  // Sends data. This should not be called again until OnDataSent is invoked.
+  void SendData(IOBuffer* data, int length, bool end_stream);
+
+  // If there is |stream_request_|, cancel it. If |stream_job_| is established,
+  // cancel it.
+  void Cancel();
+
+  // TODO(xunjieli): implement a method to do flow control and a method to ping
+  // remote end point.
+
+ private:
+  // BidirectionalStreamJob::Delegate implementation:
+  void OnRequestHeadersSent() override;
+  void OnHeaders(const SpdyHeaderBlock& response_headers) override;
+  void OnReadCompleted(int bytes_read) override;
+  void OnDataSent() override;
+  void OnTrailers(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;
+  void OnBidirectionalStreamJobReady(const SSLConfig& used_ssl_config,
+                                     const ProxyInfo& used_proxy_info,
+                                     BidirectionalStreamJob* stream) override;
+  void OnWebSocketHandshakeStreamReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      WebSocketHandshakeStreamBase* stream) override;
+  void OnStreamFailed(int status,
+                      const SSLConfig& used_ssl_config,
+                      SSLFailureState ssl_failure_state) override;
+  void OnCertificateError(int status,
+                          const SSLConfig& used_ssl_config,
+                          const SSLInfo& ssl_info) override;
+  void OnNeedsProxyAuth(const HttpResponseInfo& response_info,
+                        const SSLConfig& used_ssl_config,
+                        const ProxyInfo& used_proxy_info,
+                        HttpAuthController* auth_controller) override;
+  void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
+                         SSLCertRequestInfo* cert_info) override;
+  void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
+                                  const SSLConfig& used_ssl_config,
+                                  const ProxyInfo& used_proxy_info,
+                                  HttpStream* stream) override;
+
+  const RequestInfo request_info_;
+  RequestPriority priority_;
+  BoundNetLog net_log_;
+
+  Delegate* delegate_;
+
+  scoped_ptr<HttpStreamRequest> stream_request_;
+  scoped_ptr<BidirectionalStreamJob> stream_job_;
+
+  DISALLOW_COPY_AND_ASSIGN(BidirectionalStream);
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_BIDIRECTIONAL_STREAM_H_