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

components/grpc_support/cronet_c_for_grpc.cc

 // 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.
 
-#include "components/cronet/ios/cronet_c_for_grpc.h"
+#include "components/grpc_support/cronet_c_for_grpc.h"
 
 #include <stdbool.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #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/cronet_bidirectional_stream.h"
+#include "components/grpc_support/environment.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/bidirectional_stream.h"
 #include "net/http/bidirectional_stream_request_info.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
@@ skipping 30 matching lines @@
     headers[i].value = headers_strings_[i].second.c_str();
     ++i;
   }
 }
 
 HeadersArray::~HeadersArray() {
   delete[] headers;
 }
 
 class CronetBidirectionalStreamAdapter
-    : public cronet::CronetBidirectionalStream::Delegate {
+    : public grpc_support::CronetBidirectionalStream::Delegate {
  public:
   CronetBidirectionalStreamAdapter(
       cronet_engine* engine,
       cronet_bidirectional_stream* stream,
       cronet_bidirectional_stream_callback* callback);
 
   virtual ~CronetBidirectionalStreamAdapter();
 
   void OnStreamReady() override;
 
   void OnHeadersReceived(const net::SpdyHeaderBlock& headers_block,
                          const char* negotiated_protocol) override;
 
   void OnDataRead(char* data, int size) override;
 
   void OnDataSent(const char* data) override;
 
   void OnTrailersReceived(const net::SpdyHeaderBlock& trailers_block) override;
 
   void OnSucceeded() override;
 
   void OnFailed(int error) override;
 
   void OnCanceled() override;
 
-  static cronet::CronetBidirectionalStream* GetCronetStream(
+  static grpc_support::CronetBidirectionalStream* GetCronetStream(
       cronet_bidirectional_stream* stream);
 
   static void DestroyAdapterForStream(cronet_bidirectional_stream* stream);
 
  private:
   void DestroyOnNetworkThread();
 
   // None of these objects are owned by |this|.
-  cronet::CronetEnvironment* cronet_environment_;
-  cronet::CronetBidirectionalStream* cronet_bidirectional_stream_;
+  grpc_support::Environment* environment_;
+  grpc_support::CronetBidirectionalStream* cronet_bidirectional_stream_;
   // C side
   cronet_bidirectional_stream* stream_;
   cronet_bidirectional_stream_callback* callback_;
 };
 
 CronetBidirectionalStreamAdapter::CronetBidirectionalStreamAdapter(
     cronet_engine* engine,
     cronet_bidirectional_stream* stream,
     cronet_bidirectional_stream_callback* callback)
-    : cronet_environment_(
-          reinterpret_cast<cronet::CronetEnvironment*>(engine->obj)),
+    : environment_(
+          reinterpret_cast<grpc_support::Environment*>(engine->obj)),
       stream_(stream),
       callback_(callback) {
-  DCHECK(cronet_environment_);
+  DCHECK(environment_);
   cronet_bidirectional_stream_ =
-      new cronet::CronetBidirectionalStream(cronet_environment_, this);
+      new grpc_support::CronetBidirectionalStream(environment_, this);
 }
 
 CronetBidirectionalStreamAdapter::~CronetBidirectionalStreamAdapter() {}
 
 void CronetBidirectionalStreamAdapter::OnStreamReady() {
   DCHECK(callback_->on_response_headers_received);
   callback_->on_stream_ready(stream_);
 }
 
 void CronetBidirectionalStreamAdapter::OnHeadersReceived(
@@ skipping 30 matching lines @@
 void CronetBidirectionalStreamAdapter::OnFailed(int error) {
   DCHECK(callback_->on_failed);
   callback_->on_failed(stream_, error);
 }
 
 void CronetBidirectionalStreamAdapter::OnCanceled() {
   DCHECK(callback_->on_canceled);
   callback_->on_canceled(stream_);
 }
 
-cronet::CronetBidirectionalStream*
+grpc_support::CronetBidirectionalStream*
 CronetBidirectionalStreamAdapter::GetCronetStream(
     cronet_bidirectional_stream* stream) {
   DCHECK(stream);
   CronetBidirectionalStreamAdapter* adapter =
       static_cast<CronetBidirectionalStreamAdapter*>(stream->obj);
   DCHECK(adapter->stream_ == stream);
   DCHECK(adapter->cronet_bidirectional_stream_);
   return adapter->cronet_bidirectional_stream_;
 }
 
 void CronetBidirectionalStreamAdapter::DestroyAdapterForStream(
     cronet_bidirectional_stream* stream) {
   DCHECK(stream);
   CronetBidirectionalStreamAdapter* adapter =
       static_cast<CronetBidirectionalStreamAdapter*>(stream->obj);
   DCHECK(adapter->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(
+  adapter->environment_->PostToNetworkThread(
       FROM_HERE,
       base::Bind(&CronetBidirectionalStreamAdapter::DestroyOnNetworkThread,
                  base::Unretained(adapter)));
 }
 
 void CronetBidirectionalStreamAdapter::DestroyOnNetworkThread() {
-  DCHECK(cronet_environment_->IsOnNetworkThread());
+  DCHECK(environment_->IsOnNetworkThread());
   delete this;
 }
 
 }  // namespace
 
 cronet_bidirectional_stream* cronet_bidirectional_stream_create(
     cronet_engine* engine,
     void* annotation,
     cronet_bidirectional_stream_callback* callback) {
   // Allocate C |stream| object.
@@ skipping 24 matching lines @@
       ->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 =
+  grpc_support::CronetBidirectionalStream* cronet_stream =
       CronetBidirectionalStreamAdapter::GetCronetStream(stream);
   net::HttpRequestHeaders request_headers;
   if (headers) {
     for (size_t i = 0; i < headers->count; ++i) {
       std::string name(headers->headers[i].key);
       std::string value(headers->headers[i].value);
       if (!net::HttpUtil::IsValidHeaderName(name) ||
           !net::HttpUtil::IsValidHeaderValue(value)) {
         DLOG(ERROR) << "Invalid Header " << name << "=" << value;
         return i + 1;
@@ skipping 20 matching lines @@
       buffer, count, end_of_stream);
 }
 
 void cronet_bidirectional_stream_flush(cronet_bidirectional_stream* stream) {
   return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Flush();
 }
 
 void cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream) {
   CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Cancel();
 }