chrome/browser/extensions/api/serial/serial_io_handler.cc

   1 // Copyright 2013 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 "chrome/browser/extensions/api/serial/serial_io_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9
  10 namespace extensions {
  11
  12 SerialIoHandler::SerialIoHandler()
  13     : file_(base::kInvalidPlatformFileValue),
  14       pending_read_buffer_len_(0),
  15       pending_write_buffer_len_(0) {
  16 }
  17
  18 SerialIoHandler::~SerialIoHandler() {
  19   DCHECK(CalledOnValidThread());
  20 }
  21
  22 void SerialIoHandler::Initialize(base::PlatformFile file,
  23                                  const ReadCompleteCallback& read_callback,
  24                                  const WriteCompleteCallback& write_callback) {
  25   DCHECK(CalledOnValidThread());
  26   DCHECK_EQ(file_, base::kInvalidPlatformFileValue);
  27
  28   file_ = file;
  29   read_complete_ = read_callback;
  30   write_complete_ = write_callback;
  31
  32   InitializeImpl();
  33 }
  34
  35 void SerialIoHandler::Read(int max_bytes) {
  36   DCHECK(CalledOnValidThread());
  37   DCHECK(!IsReadPending());
  38   pending_read_buffer_ = new net::IOBuffer(max_bytes);
  39   pending_read_buffer_len_ = max_bytes;
  40   read_canceled_ = false;
  41   AddRef();
  42   ReadImpl();
  43 }
  44
  45 void SerialIoHandler::Write(const std::string& data) {
  46   DCHECK(CalledOnValidThread());
  47   DCHECK(!IsWritePending());
  48   pending_write_buffer_ = new net::IOBuffer(data.length());
  49   pending_write_buffer_len_ = data.length();
  50   memcpy(pending_write_buffer_->data(), data.data(), pending_write_buffer_len_);
  51   write_canceled_ = false;
  52   AddRef();
  53   WriteImpl();
  54 }
  55
  56 void SerialIoHandler::ReadCompleted(int bytes_read,
  57                                     api::serial::ReceiveError error) {
  58   DCHECK(CalledOnValidThread());
  59   DCHECK(IsReadPending());
  60   read_complete_.Run(std::string(pending_read_buffer_->data(), bytes_read),
  61                      error);
  62   pending_read_buffer_ = NULL;
  63   pending_read_buffer_len_ = 0;
  64   Release();
  65 }
  66
  67 void SerialIoHandler::WriteCompleted(int bytes_written,
  68                                      api::serial::SendError error) {
  69   DCHECK(CalledOnValidThread());
  70   DCHECK(IsWritePending());
  71   write_complete_.Run(bytes_written, error);
  72   pending_write_buffer_ = NULL;
  73   pending_write_buffer_len_ = 0;
  74   Release();
  75 }
  76
  77 bool SerialIoHandler::IsReadPending() const {
  78   DCHECK(CalledOnValidThread());
  79   return pending_read_buffer_ != NULL;
  80 }
  81
  82 bool SerialIoHandler::IsWritePending() const {
  83   DCHECK(CalledOnValidThread());
  84   return pending_write_buffer_ != NULL;
  85 }
  86
  87 void SerialIoHandler::CancelRead(api::serial::ReceiveError reason) {
  88   DCHECK(CalledOnValidThread());
  89   if (IsReadPending()) {
  90     read_canceled_ = true;
  91     read_cancel_reason_ = reason;
  92     CancelReadImpl();
  93   }
  94 }
  95
  96 void SerialIoHandler::CancelWrite(api::serial::SendError reason) {
  97   DCHECK(CalledOnValidThread());
  98   if (IsWritePending()) {
  99     write_canceled_ = true;
 100     write_cancel_reason_ = reason;
 101     CancelWriteImpl();
 102   }
 103 }
 104
 105 void SerialIoHandler::QueueReadCompleted(int bytes_read,
 106                                          api::serial::ReceiveError error) {
 107   base::MessageLoop::current()->PostTask(
 108       FROM_HERE, base::Bind(&SerialIoHandler::ReadCompleted, this,
 109                             bytes_read, error));
 110 }
 111
 112 void SerialIoHandler::QueueWriteCompleted(int bytes_written,
 113                                           api::serial::SendError error) {
 114   base::MessageLoop::current()->PostTask(
 115       FROM_HERE, base::Bind(&SerialIoHandler::WriteCompleted, this,
 116                             bytes_written, error));
 117 }
 118
 119 }  // namespace extensions
 120