base/sync_socket_nacl.cc

   1 // Copyright (c) 2012 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 "base/sync_socket.h"
   6
   7 #include <errno.h>
   8 #include <limits.h>
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11
  12 #include "base/logging.h"
  13
  14 namespace base {
  15
  16 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
  17
  18 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {
  19 }
  20
  21 SyncSocket::~SyncSocket() {
  22   Close();
  23 }
  24
  25 // static
  26 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
  27   return false;
  28 }
  29
  30 // static
  31 SyncSocket::Handle SyncSocket::UnwrapHandle(
  32     const SyncSocket::TransitDescriptor& descriptor) {
  33   // TODO(xians): Still unclear how NaCl uses SyncSocket.
  34   // See http://crbug.com/409656
  35   NOTIMPLEMENTED();
  36   return SyncSocket::kInvalidHandle;
  37 }
  38
  39 bool SyncSocket::PrepareTransitDescriptor(
  40     ProcessHandle peer_process_handle,
  41     SyncSocket::TransitDescriptor* descriptor) {
  42   // TODO(xians): Still unclear how NaCl uses SyncSocket.
  43   // See http://crbug.com/409656
  44   NOTIMPLEMENTED();
  45   return false;
  46 }
  47
  48 bool SyncSocket::Close() {
  49   if (handle_ != kInvalidHandle) {
  50     if (close(handle_) < 0)
  51       DPLOG(ERROR) << "close";
  52     handle_ = kInvalidHandle;
  53   }
  54   return true;
  55 }
  56
  57 size_t SyncSocket::Send(const void* buffer, size_t length) {
  58   const ssize_t bytes_written = write(handle_, buffer, length);
  59   return bytes_written > 0 ? bytes_written : 0;
  60 }
  61
  62 size_t SyncSocket::Receive(void* buffer, size_t length) {
  63   const ssize_t bytes_read = read(handle_, buffer, length);
  64   return bytes_read > 0 ? bytes_read : 0;
  65 }
  66
  67 size_t SyncSocket::ReceiveWithTimeout(void* buffer, size_t length, TimeDelta) {
  68   NOTIMPLEMENTED();
  69   return 0;
  70 }
  71
  72 size_t SyncSocket::Peek() {
  73   NOTIMPLEMENTED();
  74   return 0;
  75 }
  76
  77 CancelableSyncSocket::CancelableSyncSocket() {
  78 }
  79
  80 CancelableSyncSocket::CancelableSyncSocket(Handle handle)
  81     : SyncSocket(handle) {
  82 }
  83
  84 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
  85   return SyncSocket::Send(buffer, length);
  86 }
  87
  88 bool CancelableSyncSocket::Shutdown() {
  89   return SyncSocket::Close();
  90 }
  91
  92 // static
  93 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
  94                                       CancelableSyncSocket* socket_b) {
  95   return SyncSocket::CreatePair(socket_a, socket_b);
  96 }
  97
  98 }  // namespace base