Moving gRPC support interfaces out of cronet and into a new component.

components/grpc_support/bidirectional_stream.h

 // Copyright 2016 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 COMPONENTS_CRONET_IOS_CRONET_BIDIRECTIONAL_STREAM_H_
-#define COMPONENTS_CRONET_IOS_CRONET_BIDIRECTIONAL_STREAM_H_
+#ifndef COMPONENTS_GRPC_SUPPORT_BIDIRECTIONAL_STREAM_H_
+#define COMPONENTS_GRPC_SUPPORT_BIDIRECTIONAL_STREAM_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "net/http/bidirectional_stream.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace net {
 class HttpRequestHeaders;
 class WrappedIOBuffer;
 }  // namespace net
 
-namespace cronet {
-
-class CronetEnvironment;
+namespace grpc_support {
 
 // An adapter to net::BidirectionalStream.
 // Created and configured from any thread. Start, ReadData, WriteData and
 // Destroy can be called on any thread (including network thread), and post
 // calls to corresponding {Start|ReadData|WriteData|Destroy}OnNetworkThread to
 // the network thread. The object is always deleted on network thread. All
 // callbacks into the Delegate are done on the network thread.
 // The app is expected to initiate the next step like ReadData or Destroy.
 // Public methods can be called on any thread.
-class CronetBidirectionalStream : public net::BidirectionalStream::Delegate {
+class BidirectionalStream : public net::BidirectionalStream::Delegate {
  public:
   class Delegate {
    public:
     virtual void OnStreamReady() = 0;
 
     virtual void OnHeadersReceived(const net::SpdyHeaderBlock& response_headers,
                                    const char* negotiated_protocol) = 0;
 
     virtual void OnDataRead(char* data, int size) = 0;
 
     virtual void OnDataSent(const char* data) = 0;
 
     virtual void OnTrailersReceived(const net::SpdyHeaderBlock& trailers) = 0;
 
     virtual void OnSucceeded() = 0;
 
     virtual void OnFailed(int error) = 0;
 
     virtual void OnCanceled() = 0;
   };
 
-  CronetBidirectionalStream(CronetEnvironment* environment, Delegate* delegate);
-  ~CronetBidirectionalStream() override;
+  BidirectionalStream(net::URLRequestContextGetter* request_context_getter,
+                      Delegate* delegate);
+  ~BidirectionalStream() override;
 
   // Disables automatic flushing of each buffer passed to WriteData().
   void disable_auto_flush(bool disable_auto_flush) {
     disable_auto_flush_ = disable_auto_flush;
   }
 
   // Delays sending request headers until first call to Flush().
   void delay_headers_until_flush(bool delay_headers_until_flush) {
     delay_headers_until_flush_ = delay_headers_until_flush;
   }
@@ skipping 44 matching lines @@
     // Waiting for ReadData() to be called.
     WAITING_FOR_READ,
     // Reading from the remote, OnDataRead callback will be invoked when done.
     READING,
     // There is no more data to read and stream is half-closed by the remote
     // side.
     READING_DONE,
     // Stream is canceled.
     CANCELED,
     // Error has occured, stream is closed.
-    ERROR,
+    ERR,
     // Reading and writing are done, and the stream is closed successfully.
     SUCCESS,
     // Waiting for Flush() to be called.
     WAITING_FOR_FLUSH,
     // Writing to the remote, callback will be invoked when done.
     WRITING,
     // There is no more data to write and stream is half-closed by the local
     // side.
     WRITING_DONE,
   };
@@ skipping 47 matching lines @@
   void ReadDataOnNetworkThread(scoped_refptr<net::WrappedIOBuffer> read_buffer,
                                int buffer_size);
   void WriteDataOnNetworkThread(scoped_refptr<net::WrappedIOBuffer> read_buffer,
                                 int buffer_size,
                                 bool end_of_stream);
   void FlushOnNetworkThread();
   void SendFlushingWriteData();
   void CancelOnNetworkThread();
   void DestroyOnNetworkThread();
 
+  bool IsOnNetworkThread();
+  void PostToNetworkThread(const tracked_objects::Location& from_here,
+                           const base::Closure& task);
+
   // Read state is tracking reading flow. Only accessed on network thread.
-  //                         / <--- READING <--- \
+  //                         | <--- READING <--- |
   //                         |                   |
-  //                         \                   /
+  //                         |                   |
   // NOT_STARTED -> STARTED --> WAITING_FOR_READ -> READING_DONE -> SUCCESS
   State read_state_;
 
   // Write state is tracking writing flow.  Only accessed on network thread.
-  //                         / <--- WRITING <---  \
+  //                         | <--- WRITING <---  |
   //                         |                    |
-  //                         \                    /
+  //                         |                    |
   // NOT_STARTED -> STARTED --> WAITING_FOR_FLUSH -> WRITING_DONE -> SUCCESS
   State write_state_;
 
   bool write_end_of_stream_;
   bool request_headers_sent_;
 
   bool disable_auto_flush_;
   bool delay_headers_until_flush_;
 
-  CronetEnvironment* const environment_;
+  net::URLRequestContextGetter* const request_context_getter_;
 
   scoped_refptr<net::WrappedIOBuffer> read_buffer_;
 
   // Write data that is pending the flush.
   std::unique_ptr<WriteBuffers> pending_write_data_;
   // Write data that is flushed, but not sending yet.
   std::unique_ptr<WriteBuffers> flushing_write_data_;
   // Write data that is sending.
   std::unique_ptr<WriteBuffers> sending_write_data_;
 
   std::unique_ptr<net::BidirectionalStream> bidi_stream_;
   Delegate* delegate_;
 
-  base::WeakPtr<CronetBidirectionalStream> weak_this_;
-  base::WeakPtrFactory<CronetBidirectionalStream> weak_factory_;
+  base::WeakPtr<BidirectionalStream> weak_this_;
+  base::WeakPtrFactory<BidirectionalStream> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(CronetBidirectionalStream);
+  DISALLOW_COPY_AND_ASSIGN(BidirectionalStream);
 };
 
-}  // namespace cronet
+}  // namespace grpc_support
 
-#endif  // COMPONENTS_CRONET_IOS_CRONET_BIDIRECTIONAL_STREAM_H_
+#endif  // COMPONENTS_GRPC_SUPPORT_BIDIRECTIONAL_STREAM_H_