Implement SyncSocket for untrusted NaCl builds.

base/sync_socket_nacl.cc

 // Copyright (c) 2012 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 "base/sync_socket.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <sys/types.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 
 
 namespace base {
 
 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
 
 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {
-  NOTREACHED();
 }
 
 SyncSocket::~SyncSocket() {
 }
 
 // static
 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
   return false;
 }
 
 bool SyncSocket::Close() {
- return false;
+  if (handle_ != -1) {

[brettw, 2012/07/13 23:12:55]

Can you use kInvalidHandle instead of -1 in this function?

[bbudge, 2012/07/13 23:44:05]

Done.

+    close(handle_);

[Mark Seaborn, 2012/07/13 23:18:32]

Please check the return value of close()

[bbudge, 2012/07/13 23:44:05]

Done.

+    handle_ = -1;
+  }
+  return true;
 }
 
 size_t SyncSocket::Send(const void* buffer, size_t length) {
-  return 0;
+  return -1;

[brettw, 2012/07/13 23:12:55]

Can you comment why this isn't implemented?

[bbudge, 2012/07/13 23:44:05]

Done.

 }
 
 size_t SyncSocket::Receive(void* buffer, size_t length) {
-  return 0;
+  return read(handle_, buffer, length);
 }
 
 size_t SyncSocket::Peek() {
-  return 0;
+  return -1;
 }
 
-CancelableSyncSocket::CancelableSyncSocket() {}
+CancelableSyncSocket::CancelableSyncSocket() {
+}
+
 CancelableSyncSocket::CancelableSyncSocket(Handle handle)
     : SyncSocket(handle) {
 }
 
 size_t CancelableSyncSocket::Send(const void* buffer, size_t length) {
-  return 0;
+  return -1;
 }
 
 bool CancelableSyncSocket::Shutdown() {
   return false;
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return SyncSocket::CreatePair(socket_a, socket_b);
 }
 
 }  // namespace base