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..bbaad63a5e2a2fca02d869c9c05aca196db0edbc
--- /dev/null
+++ b/net/http/bidirectional_stream.h
@@ -0,0 +1,160 @@
+// 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.
+    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;
+
+   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

[mef, 2015/12/07 21:18:07]

Can we also add methods that expose some metrics from SpdyStream:

https://code.google.com/p/chromium/codesearch#chromium/src/net/spdy/spdy_stre...

GetProtocol()
raw_received_bytes()
raw_sent_bytes().

[xunjieli, 2015/12/08 16:08:46]

Done.

+  // 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_