1 // Copyright 2014 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 "extensions/browser/api/serial/serial_connection.h" 6 7 #include <string> 8 9 #include "base/files/file_path.h" 10 #include "base/lazy_instance.h" 11 #include "extensions/browser/api/api_resource_manager.h" 12 #include "extensions/common/api/serial.h" 13 14 namespace extensions { 15 16 namespace { 17 18 const int kDefaultBufferSize = 4096; 19 20 core_api::serial::SendError ConvertSendErrorFromMojo( 21 device::serial::SendError input) { 22 switch (input) { 23 case device::serial::SEND_ERROR_NONE: 24 return core_api::serial::SEND_ERROR_NONE; 25 case device::serial::SEND_ERROR_DISCONNECTED: 26 return core_api::serial::SEND_ERROR_DISCONNECTED; 27 case device::serial::SEND_ERROR_PENDING: 28 return core_api::serial::SEND_ERROR_PENDING; 29 case device::serial::SEND_ERROR_TIMEOUT: 30 return core_api::serial::SEND_ERROR_TIMEOUT; 31 case device::serial::SEND_ERROR_SYSTEM_ERROR: 32 return core_api::serial::SEND_ERROR_SYSTEM_ERROR; 33 } 34 return core_api::serial::SEND_ERROR_NONE; 35 } 36 37 core_api::serial::ReceiveError ConvertReceiveErrorFromMojo( 38 device::serial::ReceiveError input) { 39 switch (input) { 40 case device::serial::RECEIVE_ERROR_NONE: 41 return core_api::serial::RECEIVE_ERROR_NONE; 42 case device::serial::RECEIVE_ERROR_DISCONNECTED: 43 return core_api::serial::RECEIVE_ERROR_DISCONNECTED; 44 case device::serial::RECEIVE_ERROR_TIMEOUT: 45 return core_api::serial::RECEIVE_ERROR_TIMEOUT; 46 case device::serial::RECEIVE_ERROR_DEVICE_LOST: 47 return core_api::serial::RECEIVE_ERROR_DEVICE_LOST; 48 case device::serial::RECEIVE_ERROR_SYSTEM_ERROR: 49 return core_api::serial::RECEIVE_ERROR_SYSTEM_ERROR; 50 } 51 return core_api::serial::RECEIVE_ERROR_NONE; 52 } 53 54 core_api::serial::DataBits ConvertDataBitsFromMojo( 55 device::serial::DataBits input) { 56 switch (input) { 57 case device::serial::DATA_BITS_NONE: 58 return core_api::serial::DATA_BITS_NONE; 59 case device::serial::DATA_BITS_SEVEN: 60 return core_api::serial::DATA_BITS_SEVEN; 61 case device::serial::DATA_BITS_EIGHT: 62 return core_api::serial::DATA_BITS_EIGHT; 63 } 64 return core_api::serial::DATA_BITS_NONE; 65 } 66 67 device::serial::DataBits ConvertDataBitsToMojo( 68 core_api::serial::DataBits input) { 69 switch (input) { 70 case core_api::serial::DATA_BITS_NONE: 71 return device::serial::DATA_BITS_NONE; 72 case core_api::serial::DATA_BITS_SEVEN: 73 return device::serial::DATA_BITS_SEVEN; 74 case core_api::serial::DATA_BITS_EIGHT: 75 return device::serial::DATA_BITS_EIGHT; 76 } 77 return device::serial::DATA_BITS_NONE; 78 } 79 80 core_api::serial::ParityBit ConvertParityBitFromMojo( 81 device::serial::ParityBit input) { 82 switch (input) { 83 case device::serial::PARITY_BIT_NONE: 84 return core_api::serial::PARITY_BIT_NONE; 85 case device::serial::PARITY_BIT_ODD: 86 return core_api::serial::PARITY_BIT_ODD; 87 case device::serial::PARITY_BIT_NO: 88 return core_api::serial::PARITY_BIT_NO; 89 case device::serial::PARITY_BIT_EVEN: 90 return core_api::serial::PARITY_BIT_EVEN; 91 } 92 return core_api::serial::PARITY_BIT_NONE; 93 } 94 95 device::serial::ParityBit ConvertParityBitToMojo( 96 core_api::serial::ParityBit input) { 97 switch (input) { 98 case core_api::serial::PARITY_BIT_NONE: 99 return device::serial::PARITY_BIT_NONE; 100 case core_api::serial::PARITY_BIT_NO: 101 return device::serial::PARITY_BIT_NO; 102 case core_api::serial::PARITY_BIT_ODD: 103 return device::serial::PARITY_BIT_ODD; 104 case core_api::serial::PARITY_BIT_EVEN: 105 return device::serial::PARITY_BIT_EVEN; 106 } 107 return device::serial::PARITY_BIT_NONE; 108 } 109 110 core_api::serial::StopBits ConvertStopBitsFromMojo( 111 device::serial::StopBits input) { 112 switch (input) { 113 case device::serial::STOP_BITS_NONE: 114 return core_api::serial::STOP_BITS_NONE; 115 case device::serial::STOP_BITS_ONE: 116 return core_api::serial::STOP_BITS_ONE; 117 case device::serial::STOP_BITS_TWO: 118 return core_api::serial::STOP_BITS_TWO; 119 } 120 return core_api::serial::STOP_BITS_NONE; 121 } 122 123 device::serial::StopBits ConvertStopBitsToMojo( 124 core_api::serial::StopBits input) { 125 switch (input) { 126 case core_api::serial::STOP_BITS_NONE: 127 return device::serial::STOP_BITS_NONE; 128 case core_api::serial::STOP_BITS_ONE: 129 return device::serial::STOP_BITS_ONE; 130 case core_api::serial::STOP_BITS_TWO: 131 return device::serial::STOP_BITS_TWO; 132 } 133 return device::serial::STOP_BITS_NONE; 134 } 135 136 class SendBuffer : public device::ReadOnlyBuffer { 137 public: 138 SendBuffer( 139 const std::string& data, 140 const base::Callback<void(int, device::serial::SendError)>& callback) 141 : data_(data), callback_(callback) {} 142 virtual ~SendBuffer() {} 143 virtual const char* GetData() OVERRIDE { return data_.c_str(); } 144 virtual uint32_t GetSize() OVERRIDE { 145 return static_cast<uint32_t>(data_.size()); 146 } 147 virtual void Done(uint32_t bytes_read) OVERRIDE { 148 callback_.Run(bytes_read, device::serial::SEND_ERROR_NONE); 149 } 150 virtual void DoneWithError(uint32_t bytes_read, int32_t error) OVERRIDE { 151 callback_.Run(bytes_read, static_cast<device::serial::SendError>(error)); 152 } 153 154 private: 155 const std::string data_; 156 const base::Callback<void(int, device::serial::SendError)> callback_; 157 }; 158 159 class ReceiveBuffer : public device::WritableBuffer { 160 public: 161 ReceiveBuffer( 162 scoped_refptr<net::IOBuffer> buffer, 163 uint32_t size, 164 const base::Callback<void(int, device::serial::ReceiveError)>& callback) 165 : buffer_(buffer), size_(size), callback_(callback) {} 166 virtual ~ReceiveBuffer() {} 167 virtual char* GetData() OVERRIDE { return buffer_->data(); } 168 virtual uint32_t GetSize() OVERRIDE { return size_; } 169 virtual void Done(uint32_t bytes_written) OVERRIDE { 170 callback_.Run(bytes_written, device::serial::RECEIVE_ERROR_NONE); 171 } 172 virtual void DoneWithError(uint32_t bytes_written, int32_t error) OVERRIDE { 173 callback_.Run(bytes_written, 174 static_cast<device::serial::ReceiveError>(error)); 175 } 176 177 private: 178 scoped_refptr<net::IOBuffer> buffer_; 179 const uint32_t size_; 180 const base::Callback<void(int, device::serial::ReceiveError)> callback_; 181 }; 182 183 } // namespace 184 185 static base::LazyInstance< 186 BrowserContextKeyedAPIFactory<ApiResourceManager<SerialConnection> > > 187 g_factory = LAZY_INSTANCE_INITIALIZER; 188 189 // static 190 template <> 191 BrowserContextKeyedAPIFactory<ApiResourceManager<SerialConnection> >* 192 ApiResourceManager<SerialConnection>::GetFactoryInstance() { 193 return g_factory.Pointer(); 194 } 195 196 SerialConnection::SerialConnection(const std::string& port, 197 const std::string& owner_extension_id) 198 : ApiResource(owner_extension_id), 199 port_(port), 200 persistent_(false), 201 buffer_size_(kDefaultBufferSize), 202 receive_timeout_(0), 203 send_timeout_(0), 204 paused_(false), 205 io_handler_(device::SerialIoHandler::Create( 206 content::BrowserThread::GetMessageLoopProxyForThread( 207 content::BrowserThread::FILE))) { 208 DCHECK_CURRENTLY_ON(BrowserThread::IO); 209 } 210 211 SerialConnection::~SerialConnection() { 212 io_handler_->CancelRead(device::serial::RECEIVE_ERROR_DISCONNECTED); 213 io_handler_->CancelWrite(device::serial::SEND_ERROR_DISCONNECTED); 214 } 215 216 bool SerialConnection::IsPersistent() const { 217 return persistent(); 218 } 219 220 void SerialConnection::set_buffer_size(int buffer_size) { 221 buffer_size_ = buffer_size; 222 } 223 224 void SerialConnection::set_receive_timeout(int receive_timeout) { 225 receive_timeout_ = receive_timeout; 226 } 227 228 void SerialConnection::set_send_timeout(int send_timeout) { 229 send_timeout_ = send_timeout; 230 } 231 232 void SerialConnection::set_paused(bool paused) { 233 paused_ = paused; 234 if (paused) { 235 io_handler_->CancelRead(device::serial::RECEIVE_ERROR_NONE); 236 } 237 } 238 239 void SerialConnection::Open(const OpenCompleteCallback& callback) { 240 DCHECK_CURRENTLY_ON(BrowserThread::IO); 241 io_handler_->Open(port_, callback); 242 } 243 244 bool SerialConnection::Receive(const ReceiveCompleteCallback& callback) { 245 DCHECK_CURRENTLY_ON(BrowserThread::IO); 246 if (!receive_complete_.is_null()) 247 return false; 248 receive_complete_ = callback; 249 receive_buffer_ = new net::IOBuffer(buffer_size_); 250 io_handler_->Read(scoped_ptr<device::WritableBuffer>(new ReceiveBuffer( 251 receive_buffer_, 252 buffer_size_, 253 base::Bind(&SerialConnection::OnAsyncReadComplete, AsWeakPtr())))); 254 receive_timeout_task_.reset(); 255 if (receive_timeout_ > 0) { 256 receive_timeout_task_.reset(new TimeoutTask( 257 base::Bind(&SerialConnection::OnReceiveTimeout, AsWeakPtr()), 258 base::TimeDelta::FromMilliseconds(receive_timeout_))); 259 } 260 return true; 261 } 262 263 bool SerialConnection::Send(const std::string& data, 264 const SendCompleteCallback& callback) { 265 DCHECK_CURRENTLY_ON(BrowserThread::IO); 266 if (!send_complete_.is_null()) 267 return false; 268 send_complete_ = callback; 269 io_handler_->Write(scoped_ptr<device::ReadOnlyBuffer>(new SendBuffer( 270 data, base::Bind(&SerialConnection::OnAsyncWriteComplete, AsWeakPtr())))); 271 send_timeout_task_.reset(); 272 if (send_timeout_ > 0) { 273 send_timeout_task_.reset(new TimeoutTask( 274 base::Bind(&SerialConnection::OnSendTimeout, AsWeakPtr()), 275 base::TimeDelta::FromMilliseconds(send_timeout_))); 276 } 277 return true; 278 } 279 280 bool SerialConnection::Configure( 281 const core_api::serial::ConnectionOptions& options) { 282 DCHECK_CURRENTLY_ON(BrowserThread::IO); 283 if (options.persistent.get()) 284 set_persistent(*options.persistent); 285 if (options.name.get()) 286 set_name(*options.name); 287 if (options.buffer_size.get()) 288 set_buffer_size(*options.buffer_size); 289 if (options.receive_timeout.get()) 290 set_receive_timeout(*options.receive_timeout); 291 if (options.send_timeout.get()) 292 set_send_timeout(*options.send_timeout); 293 bool success = io_handler_->ConfigurePort( 294 *device::serial::ConnectionOptions::From(options)); 295 io_handler_->CancelRead(device::serial::RECEIVE_ERROR_NONE); 296 return success; 297 } 298 299 void SerialConnection::SetIoHandlerForTest( 300 scoped_refptr<device::SerialIoHandler> handler) { 301 io_handler_ = handler; 302 } 303 304 bool SerialConnection::GetInfo(core_api::serial::ConnectionInfo* info) const { 305 DCHECK_CURRENTLY_ON(BrowserThread::IO); 306 info->paused = paused_; 307 info->persistent = persistent_; 308 info->name = name_; 309 info->buffer_size = buffer_size_; 310 info->receive_timeout = receive_timeout_; 311 info->send_timeout = send_timeout_; 312 device::serial::ConnectionInfoPtr port_info = io_handler_->GetPortInfo(); 313 if (!port_info) 314 return false; 315 316 info->bitrate.reset(new int(port_info->bitrate)); 317 info->data_bits = ConvertDataBitsFromMojo(port_info->data_bits); 318 info->parity_bit = ConvertParityBitFromMojo(port_info->parity_bit); 319 info->stop_bits = ConvertStopBitsFromMojo(port_info->stop_bits); 320 info->cts_flow_control.reset(new bool(port_info->cts_flow_control)); 321 return true; 322 } 323 324 bool SerialConnection::Flush() const { 325 return io_handler_->Flush(); 326 } 327 328 bool SerialConnection::GetControlSignals( 329 core_api::serial::DeviceControlSignals* control_signals) const { 330 device::serial::DeviceControlSignalsPtr signals = 331 io_handler_->GetControlSignals(); 332 if (!signals) 333 return false; 334 335 control_signals->dcd = signals->dcd; 336 control_signals->cts = signals->cts; 337 control_signals->ri = signals->ri; 338 control_signals->dsr = signals->dsr; 339 return true; 340 } 341 342 bool SerialConnection::SetControlSignals( 343 const core_api::serial::HostControlSignals& control_signals) { 344 return io_handler_->SetControlSignals( 345 *device::serial::HostControlSignals::From(control_signals)); 346 } 347 348 void SerialConnection::OnReceiveTimeout() { 349 DCHECK_CURRENTLY_ON(BrowserThread::IO); 350 io_handler_->CancelRead(device::serial::RECEIVE_ERROR_TIMEOUT); 351 } 352 353 void SerialConnection::OnSendTimeout() { 354 DCHECK_CURRENTLY_ON(BrowserThread::IO); 355 io_handler_->CancelWrite(device::serial::SEND_ERROR_TIMEOUT); 356 } 357 358 void SerialConnection::OnAsyncReadComplete(int bytes_read, 359 device::serial::ReceiveError error) { 360 DCHECK_CURRENTLY_ON(BrowserThread::IO); 361 DCHECK(!receive_complete_.is_null()); 362 ReceiveCompleteCallback callback = receive_complete_; 363 receive_complete_.Reset(); 364 receive_timeout_task_.reset(); 365 callback.Run(std::string(receive_buffer_->data(), bytes_read), 366 ConvertReceiveErrorFromMojo(error)); 367 receive_buffer_ = NULL; 368 } 369 370 void SerialConnection::OnAsyncWriteComplete(int bytes_sent, 371 device::serial::SendError error) { 372 DCHECK_CURRENTLY_ON(BrowserThread::IO); 373 DCHECK(!send_complete_.is_null()); 374 SendCompleteCallback callback = send_complete_; 375 send_complete_.Reset(); 376 send_timeout_task_.reset(); 377 callback.Run(bytes_sent, ConvertSendErrorFromMojo(error)); 378 } 379 380 SerialConnection::TimeoutTask::TimeoutTask(const base::Closure& closure, 381 const base::TimeDelta& delay) 382 : weak_factory_(this), closure_(closure), delay_(delay) { 383 base::MessageLoop::current()->PostDelayedTask( 384 FROM_HERE, 385 base::Bind(&TimeoutTask::Run, weak_factory_.GetWeakPtr()), 386 delay_); 387 } 388 389 SerialConnection::TimeoutTask::~TimeoutTask() { 390 } 391 392 void SerialConnection::TimeoutTask::Run() const { 393 closure_.Run(); 394 } 395 396 } // namespace extensions 397 398 namespace mojo { 399 400 // static 401 device::serial::HostControlSignalsPtr 402 TypeConverter<device::serial::HostControlSignalsPtr, 403 extensions::core_api::serial::HostControlSignals>:: 404 Convert(const extensions::core_api::serial::HostControlSignals& input) { 405 device::serial::HostControlSignalsPtr output( 406 device::serial::HostControlSignals::New()); 407 if (input.dtr.get()) { 408 output->has_dtr = true; 409 output->dtr = *input.dtr; 410 } 411 if (input.rts.get()) { 412 output->has_rts = true; 413 output->rts = *input.rts; 414 } 415 return output.Pass(); 416 } 417 418 // static 419 device::serial::ConnectionOptionsPtr 420 TypeConverter<device::serial::ConnectionOptionsPtr, 421 extensions::core_api::serial::ConnectionOptions>:: 422 Convert(const extensions::core_api::serial::ConnectionOptions& input) { 423 device::serial::ConnectionOptionsPtr output( 424 device::serial::ConnectionOptions::New()); 425 if (input.bitrate.get() && *input.bitrate > 0) 426 output->bitrate = *input.bitrate; 427 output->data_bits = extensions::ConvertDataBitsToMojo(input.data_bits); 428 output->parity_bit = extensions::ConvertParityBitToMojo(input.parity_bit); 429 output->stop_bits = extensions::ConvertStopBitsToMojo(input.stop_bits); 430 if (input.cts_flow_control.get()) { 431 output->has_cts_flow_control = true; 432 output->cts_flow_control = *input.cts_flow_control; 433 } 434 return output.Pass(); 435 } 436 437 } // namespace mojo 438
