// Copyright 2013 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 "chrome/browser/extensions/api/serial/serial_io_handler.h"

#include "base/bind.h"
#include "base/message_loop/message_loop.h"

namespace {
#if defined(OS_WIN)
const base::PlatformFile kInvalidPlatformFileValue = INVALID_HANDLE_VALUE;
#elif defined(OS_POSIX)
const base::PlatformFile kInvalidPlatformFileValue = -1;
#endif
}  // namespace

namespace extensions {

SerialIoHandler::SerialIoHandler()
    : file_(kInvalidPlatformFileValue),
      pending_read_buffer_len_(0),
      pending_write_buffer_len_(0) {
}

SerialIoHandler::~SerialIoHandler() {
  DCHECK(CalledOnValidThread());
}

void SerialIoHandler::Initialize(base::PlatformFile file,
                                 const ReadCompleteCallback& read_callback,
                                 const WriteCompleteCallback& write_callback) {
  DCHECK(CalledOnValidThread());
  DCHECK_EQ(file_, kInvalidPlatformFileValue);

  file_ = file;
  read_complete_ = read_callback;
  write_complete_ = write_callback;

  InitializeImpl();
}

void SerialIoHandler::Read(int max_bytes) {
  DCHECK(CalledOnValidThread());
  DCHECK(!IsReadPending());
  pending_read_buffer_ = new net::IOBuffer(max_bytes);
  pending_read_buffer_len_ = max_bytes;
  read_canceled_ = false;
  AddRef();
  ReadImpl();
}

void SerialIoHandler::Write(const std::string& data) {
  DCHECK(CalledOnValidThread());
  DCHECK(!IsWritePending());
  pending_write_buffer_ = new net::IOBuffer(data.length());
  pending_write_buffer_len_ = data.length();
  memcpy(pending_write_buffer_->data(), data.data(), pending_write_buffer_len_);
  write_canceled_ = false;
  AddRef();
  WriteImpl();
}

void SerialIoHandler::ReadCompleted(int bytes_read,
                                    api::serial::ReceiveError error) {
  DCHECK(CalledOnValidThread());
  DCHECK(IsReadPending());
  read_complete_.Run(std::string(pending_read_buffer_->data(), bytes_read),
                     error);
  pending_read_buffer_ = NULL;
  pending_read_buffer_len_ = 0;
  Release();
}

void SerialIoHandler::WriteCompleted(int bytes_written,
                                     api::serial::SendError error) {
  DCHECK(CalledOnValidThread());
  DCHECK(IsWritePending());
  write_complete_.Run(bytes_written, error);
  pending_write_buffer_ = NULL;
  pending_write_buffer_len_ = 0;
  Release();
}

bool SerialIoHandler::IsReadPending() const {
  DCHECK(CalledOnValidThread());
  return pending_read_buffer_ != NULL;
}

bool SerialIoHandler::IsWritePending() const {
  DCHECK(CalledOnValidThread());
  return pending_write_buffer_ != NULL;
}

void SerialIoHandler::CancelRead(api::serial::ReceiveError reason) {
  DCHECK(CalledOnValidThread());
  if (IsReadPending()) {
    read_canceled_ = true;
    read_cancel_reason_ = reason;
    CancelReadImpl();
  }
}

void SerialIoHandler::CancelWrite(api::serial::SendError reason) {
  DCHECK(CalledOnValidThread());
  if (IsWritePending()) {
    write_canceled_ = true;
    write_cancel_reason_ = reason;
    CancelWriteImpl();
  }
}

void SerialIoHandler::QueueReadCompleted(int bytes_read,
                                         api::serial::ReceiveError error) {
  base::MessageLoop::current()->PostTask(
      FROM_HERE, base::Bind(&SerialIoHandler::ReadCompleted, this,
                            bytes_read, error));
}

void SerialIoHandler::QueueWriteCompleted(int bytes_written,
                                          api::serial::SendError error) {
  base::MessageLoop::current()->PostTask(
      FROM_HERE, base::Bind(&SerialIoHandler::WriteCompleted, this,
                            bytes_written, error));
}

}  // namespace extensions