Add SyncSocket::ReceiveWithTimeout() and SyncSocket unit tests.

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>
@@ skipping 20 matching lines @@
   if (handle_ != kInvalidHandle) {
     if (close(handle_) < 0)
       DPLOG(ERROR) << "close";
     handle_ = -1;
   }
   return true;
 }
 
 size_t SyncSocket::Send(const void* buffer, size_t length) {
   // Not implemented since it's not needed by any client code yet.
-  return -1;
+  NOTIMPLEMENTED();
+  return 0;
 }
 
 size_t SyncSocket::Receive(void* buffer, size_t length) {
   return read(handle_, buffer, length);
 }
 
+size_t SyncSocket::ReceiveWithTimeout(void* buffer, size_t length, TimeDelta) {
+  NOTIMPLEMENTED();
+  return 0;

[jar (doing other things), 2013/10/14 22:49:18]

When I argued for returning 0 (not -1), I was more sure about your function..
which didn't define an error return value.

It seems compliant to return 0, since you "read nothing" (during this notably
poor, in fact unimplemented, method).

For the other methods, they *might* have error semantics, and hence they *might*
have a return value of -1 considered as meaningful.

As a result, unless you investigate, I'd restrict this change to your function.

[DaleCurtis, 2013/10/14 23:12:33]

Only Receive(), Shutdown() are currently called by untrusted code:
https://code.google.com/p/chromium/codesearch#chromium/src/ppapi/proxy/audio_...
https://code.google.com/p/chromium/codesearch#chromium/src/ppapi/shared_impl/...

I think there's actually a bug since Close() is never called from the untrusted
side.

I'll actually be adding a Send() implementation in a follow up patch set
shortly.  All of this work on SyncSocket is to facilitate this audio change:
https://codereview.chromium.org/22886005/

If you prefer, I can save these changes for that patch set and just return 0 for
the new method in this one.

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