SyncSocket Transit Descriptor - refactoring

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/logging.h"
 
 namespace base {
 
 const SyncSocket::Handle SyncSocket::kInvalidHandle = -1;
 
 SyncSocket::SyncSocket() : handle_(kInvalidHandle) {
 }
 
 SyncSocket::~SyncSocket() {
   Close();
 }
 
 // static
 bool SyncSocket::CreatePair(SyncSocket* socket_a, SyncSocket* socket_b) {
   return false;
 }
 
+// static
+SyncSocket::Handle SyncSocket::UnwrapHandle(
+    const SyncSocket::TransitDescriptor& descriptor) {
+  // TODO(burnik): Still unclear how NaCl uses SyncSocket.

[henrika (OOO until Aug 14), 2014/09/02 07:46:05]

Nit, not sure if you should add put it on xians instead. Just don't want it to
be hanging when you leave.

[burnik, 2014/09/02 10:02:54]

If Shijing agrees, I will make it so.
On 2014/09/02 07:46:05, henrika wrote:

+  // See http://crbug.com/409656
+  NOTIMPLEMENTED();

[tommi (sloooow) - chröme, 2014/09/04 11:34:09]

what platforms will this run on?

[burnik, 2014/09/06 18:17:09]

NOTIMPLEMENTED is used in the rest of this NaCl SyncSocket so it should be safe
to use it here. It should run in any NaCl env. Point is that a test should fail
on this code once someone starts using it. Looks to me like a lot of SyncSocket
methods on NaCl are yet to be implemented here.

On 2014/09/04 11:34:09, tommi wrote:

+  return SyncSocket::kInvalidHandle;
+}
+
+bool SyncSocket::PrepareTransitDescriptor(
+    ProcessHandle peer_process_handle,
+    SyncSocket::TransitDescriptor* descriptor) {
+  // TODO(burnik): Still unclear how NaCl uses SyncSocket.
+  // See http://crbug.com/409656
+  NOTIMPLEMENTED();
+  return false;
+}
+
 bool SyncSocket::Close() {
   if (handle_ != kInvalidHandle) {
     if (close(handle_) < 0)
       DPLOG(ERROR) << "close";
     handle_ = kInvalidHandle;
   }
   return true;
 }
 
 size_t SyncSocket::Send(const void* buffer, size_t length) {
@@ skipping 31 matching lines @@
   return SyncSocket::Close();
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return SyncSocket::CreatePair(socket_a, socket_b);
 }
 
 }  // namespace base