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

components/grpc_support/bidirectional_stream_c.cc

Index: components/grpc_support/bidirectional_stream_c.cc
diff --git a/components/cronet/ios/cronet_c_for_grpc.cc b/components/grpc_support/bidirectional_stream_c.cc
similarity index 47%
rename from components/cronet/ios/cronet_c_for_grpc.cc
rename to components/grpc_support/bidirectional_stream_c.cc
index d079d20bb32b082c30129ece88f75c613442e26a..7ab1af857a368fd24a94b176a9898fdfe1687a1e 100644
--- a/components/cronet/ios/cronet_c_for_grpc.cc
+++ b/components/grpc_support/bidirectional_stream_c.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cronet/ios/cronet_c_for_grpc.h"
+#include "components/grpc_support/include/bidirectional_stream_c.h"
 
 #include <stdbool.h>
 
@@ -18,8 +18,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
-#include "components/cronet/ios/cronet_bidirectional_stream.h"
-#include "components/cronet/ios/cronet_environment.h"
+#include "components/grpc_support/bidirectional_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
@@ -38,7 +37,7 @@
 
 namespace {
 
-class HeadersArray : public cronet_bidirectional_stream_header_array {
+class HeadersArray : public bidirectional_stream_header_array {
  public:
   HeadersArray(const net::SpdyHeaderBlock& header_block);
   ~HeadersArray();
@@ -52,7 +51,7 @@ HeadersArray::HeadersArray(const net::SpdyHeaderBlock& header_block)
     : headers_strings_(header_block.size()) {
   // Count and headers are inherited from parent structure.
   count = capacity = header_block.size();
-  headers = new cronet_bidirectional_stream_header[count];
+  headers = new bidirectional_stream_header[count];
   size_t i = 0;
   // Copy headers into |headers_strings_| because string pieces are not
   // '\0'-terminated.
@@ -69,15 +68,14 @@ HeadersArray::~HeadersArray() {
   delete[] headers;
 }
 
-class CronetBidirectionalStreamAdapter
-    : public cronet::CronetBidirectionalStream::Delegate {
+class BidirectionalStreamAdapter
+    : public grpc_support::BidirectionalStream::Delegate {
  public:
-  CronetBidirectionalStreamAdapter(
-      cronet_engine* engine,
-      void* annotation,
-      cronet_bidirectional_stream_callback* callback);
+  BidirectionalStreamAdapter(stream_engine* engine,
+                             void* annotation,
+                             bidirectional_stream_callback* callback);
 
-  virtual ~CronetBidirectionalStreamAdapter();
+  virtual ~BidirectionalStreamAdapter();
 
   void OnStreamReady() override;
 
@@ -96,47 +94,47 @@ class CronetBidirectionalStreamAdapter
 
   void OnCanceled() override;
 
-  cronet_bidirectional_stream* c_stream() const { return c_stream_.get(); }
+  bidirectional_stream* c_stream() const { return c_stream_.get(); }
 
-  static cronet::CronetBidirectionalStream* GetCronetStream(
-      cronet_bidirectional_stream* stream);
+  static grpc_support::BidirectionalStream* GetStream(
+      bidirectional_stream* stream);
 
-  static void DestroyAdapterForStream(cronet_bidirectional_stream* stream);
+  static void DestroyAdapterForStream(bidirectional_stream* stream);
 
  private:
   void DestroyOnNetworkThread();
 
   // None of these objects are owned by |this|.
-  cronet::CronetEnvironment* cronet_environment_;
-  cronet::CronetBidirectionalStream* cronet_bidirectional_stream_;
+  net::URLRequestContextGetter* request_context_getter_;
+  grpc_support::BidirectionalStream* bidirectional_stream_;
   // C side
-  std::unique_ptr<cronet_bidirectional_stream> c_stream_;
-  cronet_bidirectional_stream_callback* c_callback_;
+  std::unique_ptr<bidirectional_stream> c_stream_;
+  bidirectional_stream_callback* c_callback_;
 };
 
-CronetBidirectionalStreamAdapter::CronetBidirectionalStreamAdapter(
-    cronet_engine* engine,
+BidirectionalStreamAdapter::BidirectionalStreamAdapter(
+    stream_engine* engine,
     void* annotation,
-    cronet_bidirectional_stream_callback* callback)
-    : cronet_environment_(
-          reinterpret_cast<cronet::CronetEnvironment*>(engine->obj)),
-      c_stream_(base::MakeUnique<cronet_bidirectional_stream>()),
+    bidirectional_stream_callback* callback)
+    : request_context_getter_(
+          reinterpret_cast<net::URLRequestContextGetter*>(engine->obj)),
+      c_stream_(base::MakeUnique<bidirectional_stream>()),
       c_callback_(callback) {
-  DCHECK(cronet_environment_);
-  cronet_bidirectional_stream_ =
-      new cronet::CronetBidirectionalStream(cronet_environment_, this);
+  DCHECK(request_context_getter_);
+  bidirectional_stream_ =
+      new grpc_support::BidirectionalStream(request_context_getter_, this);
   c_stream_->obj = this;
   c_stream_->annotation = annotation;
 }
 
-CronetBidirectionalStreamAdapter::~CronetBidirectionalStreamAdapter() {}
+BidirectionalStreamAdapter::~BidirectionalStreamAdapter() {}
 
-void CronetBidirectionalStreamAdapter::OnStreamReady() {
-  DCHECK(c_callback_->on_stream_ready);
+void BidirectionalStreamAdapter::OnStreamReady() {
+  DCHECK(c_callback_->on_response_headers_received);
   c_callback_->on_stream_ready(c_stream());
 }
 
-void CronetBidirectionalStreamAdapter::OnHeadersReceived(
+void BidirectionalStreamAdapter::OnHeadersReceived(
     const net::SpdyHeaderBlock& headers_block,
     const char* negotiated_protocol) {
   DCHECK(c_callback_->on_response_headers_received);
@@ -145,110 +143,107 @@ void CronetBidirectionalStreamAdapter::OnHeadersReceived(
                                             negotiated_protocol);
 }
 
-void CronetBidirectionalStreamAdapter::OnDataRead(char* data, int size) {
+void BidirectionalStreamAdapter::OnDataRead(char* data, int size) {
   DCHECK(c_callback_->on_read_completed);
   c_callback_->on_read_completed(c_stream(), data, size);
 }
 
-void CronetBidirectionalStreamAdapter::OnDataSent(const char* data) {
+void BidirectionalStreamAdapter::OnDataSent(const char* data) {
   DCHECK(c_callback_->on_write_completed);
   c_callback_->on_write_completed(c_stream(), data);
 }
 
-void CronetBidirectionalStreamAdapter::OnTrailersReceived(
+void BidirectionalStreamAdapter::OnTrailersReceived(
     const net::SpdyHeaderBlock& trailers_block) {
   DCHECK(c_callback_->on_response_trailers_received);
   HeadersArray response_trailers(trailers_block);
   c_callback_->on_response_trailers_received(c_stream(), &response_trailers);
 }
 
-void CronetBidirectionalStreamAdapter::OnSucceeded() {
+void BidirectionalStreamAdapter::OnSucceeded() {
   DCHECK(c_callback_->on_succeded);
   c_callback_->on_succeded(c_stream());
 }
 
-void CronetBidirectionalStreamAdapter::OnFailed(int error) {
+void BidirectionalStreamAdapter::OnFailed(int error) {
   DCHECK(c_callback_->on_failed);
   c_callback_->on_failed(c_stream(), error);
 }
 
-void CronetBidirectionalStreamAdapter::OnCanceled() {
+void BidirectionalStreamAdapter::OnCanceled() {
   DCHECK(c_callback_->on_canceled);
   c_callback_->on_canceled(c_stream());
 }
 
-cronet::CronetBidirectionalStream*
-CronetBidirectionalStreamAdapter::GetCronetStream(
-    cronet_bidirectional_stream* stream) {
+grpc_support::BidirectionalStream* BidirectionalStreamAdapter::GetStream(
+    bidirectional_stream* stream) {
   DCHECK(stream);
-  CronetBidirectionalStreamAdapter* adapter =
-      static_cast<CronetBidirectionalStreamAdapter*>(stream->obj);
+  BidirectionalStreamAdapter* adapter =
+      static_cast<BidirectionalStreamAdapter*>(stream->obj);
   DCHECK(adapter->c_stream() == stream);
-  DCHECK(adapter->cronet_bidirectional_stream_);
-  return adapter->cronet_bidirectional_stream_;
+  DCHECK(adapter->bidirectional_stream_);
+  return adapter->bidirectional_stream_;
 }
 
-void CronetBidirectionalStreamAdapter::DestroyAdapterForStream(
-    cronet_bidirectional_stream* stream) {
+void BidirectionalStreamAdapter::DestroyAdapterForStream(
+    bidirectional_stream* stream) {
   DCHECK(stream);
-  CronetBidirectionalStreamAdapter* adapter =
-      static_cast<CronetBidirectionalStreamAdapter*>(stream->obj);
+  BidirectionalStreamAdapter* adapter =
+      static_cast<BidirectionalStreamAdapter*>(stream->obj);
   DCHECK(adapter->c_stream() == stream);
   // Destroy could be called from any thread, including network thread (if
   // posting task to executor throws an exception), but is posted, so |this|
   // is valid until calling task is complete.
-  adapter->cronet_bidirectional_stream_->Destroy();
-  adapter->cronet_environment_->PostToNetworkThread(
-      FROM_HERE,
-      base::Bind(&CronetBidirectionalStreamAdapter::DestroyOnNetworkThread,
-                 base::Unretained(adapter)));
+  adapter->bidirectional_stream_->Destroy();
+  adapter->request_context_getter_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&BidirectionalStreamAdapter::DestroyOnNetworkThread,
+                            base::Unretained(adapter)));
 }
 
-void CronetBidirectionalStreamAdapter::DestroyOnNetworkThread() {
-  DCHECK(cronet_environment_->IsOnNetworkThread());
+void BidirectionalStreamAdapter::DestroyOnNetworkThread() {
+  DCHECK(request_context_getter_->GetNetworkTaskRunner()
+             ->BelongsToCurrentThread());
   delete this;
 }
 
 }  // namespace
 
-cronet_bidirectional_stream* cronet_bidirectional_stream_create(
-    cronet_engine* engine,
+bidirectional_stream* bidirectional_stream_create(
+    stream_engine* engine,
     void* annotation,
-    cronet_bidirectional_stream_callback* callback) {
+    bidirectional_stream_callback* callback) {
   // Allocate new C++ adapter that will invoke |callback|.
-  CronetBidirectionalStreamAdapter* stream_adapter =
-      new CronetBidirectionalStreamAdapter(engine, annotation, callback);
+  BidirectionalStreamAdapter* stream_adapter =
+      new BidirectionalStreamAdapter(engine, annotation, callback);
   return stream_adapter->c_stream();
 }
 
-int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream) {
-  CronetBidirectionalStreamAdapter::DestroyAdapterForStream(stream);
+int bidirectional_stream_destroy(bidirectional_stream* stream) {
+  BidirectionalStreamAdapter::DestroyAdapterForStream(stream);
   return 1;
 }
 
-void cronet_bidirectional_stream_disable_auto_flush(
-    cronet_bidirectional_stream* stream,
-    bool disable_auto_flush) {
-  CronetBidirectionalStreamAdapter::GetCronetStream(stream)->disable_auto_flush(
+void bidirectional_stream_disable_auto_flush(bidirectional_stream* stream,
+                                             bool disable_auto_flush) {
+  BidirectionalStreamAdapter::GetStream(stream)->disable_auto_flush(
       disable_auto_flush);
 }
 
-void cronet_bidirectional_stream_delay_request_headers_until_flush(
-    cronet_bidirectional_stream* stream,
+void bidirectional_stream_delay_request_headers_until_flush(
+    bidirectional_stream* stream,
     bool delay_headers_until_flush) {
-  CronetBidirectionalStreamAdapter::GetCronetStream(stream)
-      ->delay_headers_until_flush(delay_headers_until_flush);
+  BidirectionalStreamAdapter::GetStream(stream)->delay_headers_until_flush(
+      delay_headers_until_flush);
 }
 
-int cronet_bidirectional_stream_start(
-    cronet_bidirectional_stream* stream,
-    const char* url,
-    int priority,
-    const char* method,
-    const cronet_bidirectional_stream_header_array* headers,
-    bool end_of_stream) {
-  cronet::CronetBidirectionalStream* cronet_stream =
-      CronetBidirectionalStreamAdapter::GetCronetStream(stream);
+int bidirectional_stream_start(bidirectional_stream* stream,
+                               const char* url,
+                               int priority,
+                               const char* method,
+                               const bidirectional_stream_header_array* headers,
+                               bool end_of_stream) {
+  grpc_support::BidirectionalStream* internal_stream =
+      BidirectionalStreamAdapter::GetStream(stream);
   net::HttpRequestHeaders request_headers;
   if (headers) {
     for (size_t i = 0; i < headers->count; ++i) {
@@ -262,29 +257,29 @@ int cronet_bidirectional_stream_start(
       request_headers.SetHeader(name, value);
     }
   }
-  return cronet_stream->Start(url, priority, method, request_headers,
-                              end_of_stream);
+  return internal_stream->Start(url, priority, method, request_headers,
+                                end_of_stream);
 }
 
-int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream,
-                                     char* buffer,
-                                     int capacity) {
-  return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->ReadData(
-      buffer, capacity);
+int bidirectional_stream_read(bidirectional_stream* stream,
+                              char* buffer,
+                              int capacity) {
+  return BidirectionalStreamAdapter::GetStream(stream)->ReadData(buffer,
+                                                                 capacity);
 }
 
-int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream,
-                                      const char* buffer,
-                                      int count,
-                                      bool end_of_stream) {
-  return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->WriteData(
+int bidirectional_stream_write(bidirectional_stream* stream,
+                               const char* buffer,
+                               int count,
+                               bool end_of_stream) {
+  return BidirectionalStreamAdapter::GetStream(stream)->WriteData(
       buffer, count, end_of_stream);
 }
 
-void cronet_bidirectional_stream_flush(cronet_bidirectional_stream* stream) {
-  return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Flush();
+void bidirectional_stream_flush(bidirectional_stream* stream) {
+  return BidirectionalStreamAdapter::GetStream(stream)->Flush();
 }
 
-void cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream) {
-  CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Cancel();
+void bidirectional_stream_cancel(bidirectional_stream* stream) {
+  BidirectionalStreamAdapter::GetStream(stream)->Cancel();
 }