SyncSocket Transit Descriptor - refactoring

base/sync_socket_posix.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 <fcntl.h>
 #include <limits.h>
 #include <stdio.h>
@@ skipping 78 matching lines @@
   }
 #endif
 
   // Copy the handles out for successful return.
   socket_a->handle_ = handles[0];
   socket_b->handle_ = handles[1];
 
   return true;
 }
 
+// static
+SyncSocket::Handle SyncSocket::UnwrapHandle(
+    const TransitDescriptor& descriptor) {
+  return descriptor.fd;
+}
+
+bool SyncSocket::PrepareTransitDescriptor(ProcessHandle peer_process_handle,
+                                          TransitDescriptor* descriptor) {
+  DCHECK(descriptor);

[tommi (sloooow) - chröme, 2014/09/04 19:47:00]

nit: we generally don't add DCHECKs like this when you dereference the pointer
anyway right thereafter.

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

Done.

+  descriptor->fd = handle();
+  descriptor->auto_close = false;
+  return descriptor->fd != kInvalidHandle;
+}
+
 bool SyncSocket::Close() {
   const bool retval = CloseHandle(handle_);
   handle_ = kInvalidHandle;
   return retval;
 }
 
 size_t SyncSocket::Send(const void* buffer, size_t length) {
   ThreadRestrictions::AssertIOAllowed();
   return SendHelper(handle_, buffer, length);
 }
@@ skipping 114 matching lines @@
   return len;
 }
 
 // static
 bool CancelableSyncSocket::CreatePair(CancelableSyncSocket* socket_a,
                                       CancelableSyncSocket* socket_b) {
   return SyncSocket::CreatePair(socket_a, socket_b);
 }
 
 }  // namespace base