Update from https://crrev.com/304121

sandbox/linux/syscall_broker/broker_client.cc

 // Copyright 2014 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 "sandbox/linux/syscall_broker/broker_client.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 
 #include "build/build_config.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/posix/unix_domain_socket_linux.h"
+#include "sandbox/linux/syscall_broker/broker_channel.h"
 #include "sandbox/linux/syscall_broker/broker_common.h"
 #include "sandbox/linux/syscall_broker/broker_policy.h"
 
 #if defined(OS_ANDROID) && !defined(MSG_CMSG_CLOEXEC)
 #define MSG_CMSG_CLOEXEC 0x40000000
 #endif
 
 namespace sandbox {
 
 namespace syscall_broker {
@@ skipping 41 matching lines @@
   write_pickle.WriteInt(flags);
   RAW_CHECK(write_pickle.size() <= kMaxMessageLength);
 
   int returned_fd = -1;
   uint8_t reply_buf[kMaxMessageLength];
 
   // Send a request (in write_pickle) as well that will include a new
   // temporary socketpair (created internally by SendRecvMsg()).
   // Then read the reply on this new socketpair in reply_buf and put an
   // eventual attached file descriptor in |returned_fd|.
-  ssize_t msg_len = UnixDomainSocket::SendRecvMsgWithFlags(ipc_channel_,
-                                                           reply_buf,
-                                                           sizeof(reply_buf),
-                                                           recvmsg_flags,
-                                                           &returned_fd,
-                                                           write_pickle);
+  ssize_t msg_len = UnixDomainSocket::SendRecvMsgWithFlags(
+      ipc_channel_.get(), reply_buf, sizeof(reply_buf), recvmsg_flags,
+      &returned_fd, write_pickle);
   if (msg_len <= 0) {
     if (!quiet_failures_for_tests_)
       RAW_LOG(ERROR, "Could not make request to broker process");
     return -ENOMEM;
   }
 
   Pickle read_pickle(reinterpret_cast<char*>(reply_buf), msg_len);
   PickleIterator iter(read_pickle);
   int return_value = -1;
   // Now deserialize the return value and eventually return the file
@@ skipping 18 matching lines @@
         return -ENOSYS;
     }
   } else {
     RAW_LOG(ERROR, "Could not read pickle");
     NOTREACHED();
     return -ENOMEM;
   }
 }
 
 BrokerClient::BrokerClient(const BrokerPolicy& broker_policy,
-                           int ipc_channel,
+                           BrokerChannel::EndPoint ipc_channel,
                            bool fast_check_in_client,
                            bool quiet_failures_for_tests)
     : broker_policy_(broker_policy),
-      ipc_channel_(ipc_channel),
+      ipc_channel_(ipc_channel.Pass()),
       fast_check_in_client_(fast_check_in_client),
       quiet_failures_for_tests_(quiet_failures_for_tests) {
 }
 
 BrokerClient::~BrokerClient() {
 }
 
 int BrokerClient::Access(const char* pathname, int mode) const {
   return PathAndFlagsSyscall(COMMAND_ACCESS, pathname, mode);
 }
 
 int BrokerClient::Open(const char* pathname, int flags) const {
   return PathAndFlagsSyscall(COMMAND_OPEN, pathname, flags);
 }
 
 }  // namespace syscall_broker
 
 }  // namespace sandbox