| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/cronet/ios/cronet_c_for_grpc.h" | |
| 6 | |
| 7 #include <stdbool.h> | |
| 8 | |
| 9 #include <memory> | |
| 10 #include <string> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "base/bind.h" | |
| 14 #include "base/location.h" | |
| 15 #include "base/logging.h" | |
| 16 #include "base/macros.h" | |
| 17 #include "base/memory/ref_counted.h" | |
| 18 #include "base/strings/string_number_conversions.h" | |
| 19 #include "base/strings/string_split.h" | |
| 20 #include "components/cronet/ios/cronet_bidirectional_stream.h" | |
| 21 #include "components/cronet/ios/cronet_environment.h" | |
| 22 #include "net/base/io_buffer.h" | |
| 23 #include "net/base/net_errors.h" | |
| 24 #include "net/base/request_priority.h" | |
| 25 #include "net/http/bidirectional_stream.h" | |
| 26 #include "net/http/bidirectional_stream_request_info.h" | |
| 27 #include "net/http/http_network_session.h" | |
| 28 #include "net/http/http_response_headers.h" | |
| 29 #include "net/http/http_status_code.h" | |
| 30 #include "net/http/http_transaction_factory.h" | |
| 31 #include "net/http/http_util.h" | |
| 32 #include "net/spdy/spdy_header_block.h" | |
| 33 #include "net/ssl/ssl_info.h" | |
| 34 #include "net/url_request/http_user_agent_settings.h" | |
| 35 #include "net/url_request/url_request_context.h" | |
| 36 #include "url/gurl.h" | |
| 37 | |
| 38 namespace { | |
| 39 | |
| 40 class HeadersArray : public cronet_bidirectional_stream_header_array { | |
| 41 public: | |
| 42 HeadersArray(const net::SpdyHeaderBlock& header_block); | |
| 43 ~HeadersArray(); | |
| 44 | |
| 45 private: | |
| 46 DISALLOW_COPY_AND_ASSIGN(HeadersArray); | |
| 47 base::StringPairs headers_strings_; | |
| 48 }; | |
| 49 | |
| 50 HeadersArray::HeadersArray(const net::SpdyHeaderBlock& header_block) | |
| 51 : headers_strings_(header_block.size()) { | |
| 52 // Count and headers are inherited from parent structure. | |
| 53 count = capacity = header_block.size(); | |
| 54 headers = new cronet_bidirectional_stream_header[count]; | |
| 55 size_t i = 0; | |
| 56 // Copy headers into |headers_strings_| because string pieces are not | |
| 57 // '\0'-terminated. | |
| 58 for (const auto& it : header_block) { | |
| 59 headers_strings_[i].first = it.first.as_string(); | |
| 60 headers_strings_[i].second = it.second.as_string(); | |
| 61 headers[i].key = headers_strings_[i].first.c_str(); | |
| 62 headers[i].value = headers_strings_[i].second.c_str(); | |
| 63 ++i; | |
| 64 } | |
| 65 } | |
| 66 | |
| 67 HeadersArray::~HeadersArray() { | |
| 68 delete[] headers; | |
| 69 } | |
| 70 | |
| 71 class CronetBidirectionalStreamAdapter | |
| 72 : public cronet::CronetBidirectionalStream::Delegate { | |
| 73 public: | |
| 74 CronetBidirectionalStreamAdapter( | |
| 75 cronet_engine* engine, | |
| 76 cronet_bidirectional_stream* stream, | |
| 77 cronet_bidirectional_stream_callback* callback); | |
| 78 | |
| 79 virtual ~CronetBidirectionalStreamAdapter(); | |
| 80 | |
| 81 void OnStreamReady() override; | |
| 82 | |
| 83 void OnHeadersReceived(const net::SpdyHeaderBlock& headers_block, | |
| 84 const char* negotiated_protocol) override; | |
| 85 | |
| 86 void OnDataRead(char* data, int size) override; | |
| 87 | |
| 88 void OnDataSent(const char* data) override; | |
| 89 | |
| 90 void OnTrailersReceived(const net::SpdyHeaderBlock& trailers_block) override; | |
| 91 | |
| 92 void OnSucceeded() override; | |
| 93 | |
| 94 void OnFailed(int error) override; | |
| 95 | |
| 96 void OnCanceled() override; | |
| 97 | |
| 98 static cronet::CronetBidirectionalStream* GetCronetStream( | |
| 99 cronet_bidirectional_stream* stream); | |
| 100 | |
| 101 static void DestroyAdapterForStream(cronet_bidirectional_stream* stream); | |
| 102 | |
| 103 private: | |
| 104 void DestroyOnNetworkThread(); | |
| 105 | |
| 106 // None of these objects are owned by |this|. | |
| 107 cronet::CronetEnvironment* cronet_environment_; | |
| 108 cronet::CronetBidirectionalStream* cronet_bidirectional_stream_; | |
| 109 // C side | |
| 110 cronet_bidirectional_stream* stream_; | |
| 111 cronet_bidirectional_stream_callback* callback_; | |
| 112 }; | |
| 113 | |
| 114 CronetBidirectionalStreamAdapter::CronetBidirectionalStreamAdapter( | |
| 115 cronet_engine* engine, | |
| 116 cronet_bidirectional_stream* stream, | |
| 117 cronet_bidirectional_stream_callback* callback) | |
| 118 : cronet_environment_( | |
| 119 reinterpret_cast<cronet::CronetEnvironment*>(engine->obj)), | |
| 120 stream_(stream), | |
| 121 callback_(callback) { | |
| 122 DCHECK(cronet_environment_); | |
| 123 cronet_bidirectional_stream_ = | |
| 124 new cronet::CronetBidirectionalStream(cronet_environment_, this); | |
| 125 } | |
| 126 | |
| 127 CronetBidirectionalStreamAdapter::~CronetBidirectionalStreamAdapter() {} | |
| 128 | |
| 129 void CronetBidirectionalStreamAdapter::OnStreamReady() { | |
| 130 DCHECK(callback_->on_response_headers_received); | |
| 131 callback_->on_stream_ready(stream_); | |
| 132 } | |
| 133 | |
| 134 void CronetBidirectionalStreamAdapter::OnHeadersReceived( | |
| 135 const net::SpdyHeaderBlock& headers_block, | |
| 136 const char* negotiated_protocol) { | |
| 137 DCHECK(callback_->on_response_headers_received); | |
| 138 HeadersArray response_headers(headers_block); | |
| 139 callback_->on_response_headers_received(stream_, &response_headers, | |
| 140 negotiated_protocol); | |
| 141 } | |
| 142 | |
| 143 void CronetBidirectionalStreamAdapter::OnDataRead(char* data, int size) { | |
| 144 DCHECK(callback_->on_read_completed); | |
| 145 callback_->on_read_completed(stream_, data, size); | |
| 146 } | |
| 147 | |
| 148 void CronetBidirectionalStreamAdapter::OnDataSent(const char* data) { | |
| 149 DCHECK(callback_->on_write_completed); | |
| 150 callback_->on_write_completed(stream_, data); | |
| 151 } | |
| 152 | |
| 153 void CronetBidirectionalStreamAdapter::OnTrailersReceived( | |
| 154 const net::SpdyHeaderBlock& trailers_block) { | |
| 155 DCHECK(callback_->on_response_trailers_received); | |
| 156 HeadersArray response_trailers(trailers_block); | |
| 157 callback_->on_response_trailers_received(stream_, &response_trailers); | |
| 158 } | |
| 159 | |
| 160 void CronetBidirectionalStreamAdapter::OnSucceeded() { | |
| 161 DCHECK(callback_->on_succeded); | |
| 162 callback_->on_succeded(stream_); | |
| 163 } | |
| 164 | |
| 165 void CronetBidirectionalStreamAdapter::OnFailed(int error) { | |
| 166 DCHECK(callback_->on_failed); | |
| 167 callback_->on_failed(stream_, error); | |
| 168 } | |
| 169 | |
| 170 void CronetBidirectionalStreamAdapter::OnCanceled() { | |
| 171 DCHECK(callback_->on_canceled); | |
| 172 callback_->on_canceled(stream_); | |
| 173 } | |
| 174 | |
| 175 cronet::CronetBidirectionalStream* | |
| 176 CronetBidirectionalStreamAdapter::GetCronetStream( | |
| 177 cronet_bidirectional_stream* stream) { | |
| 178 DCHECK(stream); | |
| 179 CronetBidirectionalStreamAdapter* adapter = | |
| 180 static_cast<CronetBidirectionalStreamAdapter*>(stream->obj); | |
| 181 DCHECK(adapter->stream_ == stream); | |
| 182 DCHECK(adapter->cronet_bidirectional_stream_); | |
| 183 return adapter->cronet_bidirectional_stream_; | |
| 184 } | |
| 185 | |
| 186 void CronetBidirectionalStreamAdapter::DestroyAdapterForStream( | |
| 187 cronet_bidirectional_stream* stream) { | |
| 188 DCHECK(stream); | |
| 189 CronetBidirectionalStreamAdapter* adapter = | |
| 190 static_cast<CronetBidirectionalStreamAdapter*>(stream->obj); | |
| 191 DCHECK(adapter->stream_ == stream); | |
| 192 // Destroy could be called from any thread, including network thread (if | |
| 193 // posting task to executor throws an exception), but is posted, so |this| | |
| 194 // is valid until calling task is complete. | |
| 195 adapter->cronet_bidirectional_stream_->Destroy(); | |
| 196 adapter->cronet_environment_->PostToNetworkThread( | |
| 197 FROM_HERE, | |
| 198 base::Bind(&CronetBidirectionalStreamAdapter::DestroyOnNetworkThread, | |
| 199 base::Unretained(adapter))); | |
| 200 } | |
| 201 | |
| 202 void CronetBidirectionalStreamAdapter::DestroyOnNetworkThread() { | |
| 203 DCHECK(cronet_environment_->IsOnNetworkThread()); | |
| 204 delete this; | |
| 205 } | |
| 206 | |
| 207 } // namespace | |
| 208 | |
| 209 cronet_bidirectional_stream* cronet_bidirectional_stream_create( | |
| 210 cronet_engine* engine, | |
| 211 void* annotation, | |
| 212 cronet_bidirectional_stream_callback* callback) { | |
| 213 // Allocate C |stream| object. | |
| 214 cronet_bidirectional_stream* stream = new cronet_bidirectional_stream(); | |
| 215 // Allocate new C++ adapter that will invoke |callback|. | |
| 216 stream->obj = new CronetBidirectionalStreamAdapter(engine, stream, callback); | |
| 217 stream->annotation = annotation; | |
| 218 return stream; | |
| 219 } | |
| 220 | |
| 221 int cronet_bidirectional_stream_destroy(cronet_bidirectional_stream* stream) { | |
| 222 CronetBidirectionalStreamAdapter::DestroyAdapterForStream(stream); | |
| 223 delete stream; | |
| 224 return 1; | |
| 225 } | |
| 226 | |
| 227 void cronet_bidirectional_stream_disable_auto_flush( | |
| 228 cronet_bidirectional_stream* stream, | |
| 229 bool disable_auto_flush) { | |
| 230 CronetBidirectionalStreamAdapter::GetCronetStream(stream)->disable_auto_flush( | |
| 231 disable_auto_flush); | |
| 232 } | |
| 233 | |
| 234 void cronet_bidirectional_stream_delay_request_headers_until_flush( | |
| 235 cronet_bidirectional_stream* stream, | |
| 236 bool delay_headers_until_flush) { | |
| 237 CronetBidirectionalStreamAdapter::GetCronetStream(stream) | |
| 238 ->delay_headers_until_flush(delay_headers_until_flush); | |
| 239 } | |
| 240 | |
| 241 int cronet_bidirectional_stream_start( | |
| 242 cronet_bidirectional_stream* stream, | |
| 243 const char* url, | |
| 244 int priority, | |
| 245 const char* method, | |
| 246 const cronet_bidirectional_stream_header_array* headers, | |
| 247 bool end_of_stream) { | |
| 248 cronet::CronetBidirectionalStream* cronet_stream = | |
| 249 CronetBidirectionalStreamAdapter::GetCronetStream(stream); | |
| 250 net::HttpRequestHeaders request_headers; | |
| 251 if (headers) { | |
| 252 for (size_t i = 0; i < headers->count; ++i) { | |
| 253 std::string name(headers->headers[i].key); | |
| 254 std::string value(headers->headers[i].value); | |
| 255 if (!net::HttpUtil::IsValidHeaderName(name) || | |
| 256 !net::HttpUtil::IsValidHeaderValue(value)) { | |
| 257 DLOG(ERROR) << "Invalid Header " << name << "=" << value; | |
| 258 return i + 1; | |
| 259 } | |
| 260 request_headers.SetHeader(name, value); | |
| 261 } | |
| 262 } | |
| 263 return cronet_stream->Start(url, priority, method, request_headers, | |
| 264 end_of_stream); | |
| 265 } | |
| 266 | |
| 267 int cronet_bidirectional_stream_read(cronet_bidirectional_stream* stream, | |
| 268 char* buffer, | |
| 269 int capacity) { | |
| 270 return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->ReadData( | |
| 271 buffer, capacity); | |
| 272 } | |
| 273 | |
| 274 int cronet_bidirectional_stream_write(cronet_bidirectional_stream* stream, | |
| 275 const char* buffer, | |
| 276 int count, | |
| 277 bool end_of_stream) { | |
| 278 return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->WriteData( | |
| 279 buffer, count, end_of_stream); | |
| 280 } | |
| 281 | |
| 282 void cronet_bidirectional_stream_flush(cronet_bidirectional_stream* stream) { | |
| 283 return CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Flush(); | |
| 284 } | |
| 285 | |
| 286 void cronet_bidirectional_stream_cancel(cronet_bidirectional_stream* stream) { | |
| 287 CronetBidirectionalStreamAdapter::GetCronetStream(stream)->Cancel(); | |
| 288 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2273403003:
Moving gRPC support interfaces out of cronet and into a new component. (Closed)
