Update from https://crrev.com/302630

sandbox/linux/syscall_broker/broker_process_unittest.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 "sandbox/linux/services/broker_process.h"
+#include "sandbox/linux/syscall_broker/broker_process.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 
 class BrokerProcessTestHelper {
  public:
   static int get_ipc_socketpair(const BrokerProcess* broker) {
     return broker->ipc_socketpair_;
   }
 };
 
 namespace {
 
-bool NoOpCallback() { return true; }
+bool NoOpCallback() {
+  return true;
+}
 
 }  // namespace
 
 TEST(BrokerProcess, CreateAndDestroy) {
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back("/proc/cpuinfo");
 
   scoped_ptr<BrokerProcess> open_broker(
       new BrokerProcess(EPERM, read_whitelist, std::vector<std::string>()));
   ASSERT_TRUE(open_broker->Init(base::Bind(&NoOpCallback)));
@@ skipping 27 matching lines @@
 
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back(kR_WhiteListed);
   read_whitelist.push_back(kR_WhiteListedButDenied);
   read_whitelist.push_back(kRW_WhiteListed);
 
   std::vector<std::string> write_whitelist;
   write_whitelist.push_back(kW_WhiteListed);
   write_whitelist.push_back(kRW_WhiteListed);
 
-  BrokerProcess open_broker(denied_errno,
-                            read_whitelist,
-                            write_whitelist,
-                            fast_check_in_client);
+  BrokerProcess open_broker(
+      denied_errno, read_whitelist, write_whitelist, fast_check_in_client);
   ASSERT_TRUE(open_broker.Init(base::Bind(&NoOpCallback)));
 
   int fd = -1;
   fd = open_broker.Open(kR_WhiteListed, O_RDONLY);
   ASSERT_EQ(fd, -ENOENT);
   fd = open_broker.Open(kR_WhiteListed, O_WRONLY);
   ASSERT_EQ(fd, -denied_errno);
   fd = open_broker.Open(kR_WhiteListed, O_RDWR);
   ASSERT_EQ(fd, -denied_errno);
   int ret = -1;
@@ skipping 256 matching lines @@
   // Check that doing Open with a dead broker won't SIGPIPE us.
   SANDBOX_ASSERT(open_broker.Open("/proc/cpuinfo", O_RDONLY) == -ENOMEM);
   SANDBOX_ASSERT(open_broker.Access("/proc/cpuinfo", O_RDONLY) == -ENOMEM);
 }
 
 void TestOpenComplexFlags(bool fast_check_in_client) {
   const char kCpuInfo[] = "/proc/cpuinfo";
   std::vector<std::string> whitelist;
   whitelist.push_back(kCpuInfo);
 
-  BrokerProcess open_broker(EPERM,
-                            whitelist,
-                            whitelist,
-                            fast_check_in_client);
+  BrokerProcess open_broker(EPERM, whitelist, whitelist, fast_check_in_client);
   ASSERT_TRUE(open_broker.Init(base::Bind(&NoOpCallback)));
   // Test that we do the right thing for O_CLOEXEC and O_NONBLOCK.
   int fd = -1;
   int ret = 0;
   fd = open_broker.Open(kCpuInfo, O_RDONLY);
   ASSERT_GE(fd, 0);
   ret = fcntl(fd, F_GETFL);
   ASSERT_NE(-1, ret);
   // The descriptor shouldn't have the O_CLOEXEC attribute, nor O_NONBLOCK.
   ASSERT_EQ(0, ret & (O_CLOEXEC | O_NONBLOCK));
@@ skipping 45 matching lines @@
   base::ScopedFD message_fd(available_fds[0]);
   for (size_t i = 1; i < arraysize(available_fds); i++) {
     SANDBOX_ASSERT(0 == IGNORE_EINTR(close(available_fds[i])));
   }
 
   // Lower our file descriptor limit to just allow three more file descriptors
   // to be allocated.  (N.B., RLIMIT_NOFILE doesn't limit the number of file
   // descriptors a process can have: it only limits the highest value that can
   // be assigned to newly-created descriptors allocated by the process.)
   const rlim_t fd_limit =
-      1 + *std::max_element(available_fds,
-                            available_fds + arraysize(available_fds));
+      1 +
+      *std::max_element(available_fds,
+                        available_fds + arraysize(available_fds));
 
   // Valgrind doesn't allow changing the hard descriptor limit, so we only
   // change the soft descriptor limit here.
   struct rlimit rlim;
   SANDBOX_ASSERT(0 == getrlimit(RLIMIT_NOFILE, &rlim));
   SANDBOX_ASSERT(fd_limit <= rlim.rlim_cur);
   rlim.rlim_cur = fd_limit;
   SANDBOX_ASSERT(0 == setrlimit(RLIMIT_NOFILE, &rlim));
 
   static const char kCpuInfo[] = "/proc/cpuinfo";
@@ skipping 16 matching lines @@
     SANDBOX_ASSERT(
         UnixDomainSocket::SendMsg(ipc_fd, kBogus, sizeof(kBogus), fds));
   }
 
   const int fd = open_broker.Open(kCpuInfo, O_RDONLY);
   SANDBOX_ASSERT(fd >= 0);
   SANDBOX_ASSERT(0 == IGNORE_EINTR(close(fd)));
 }
 
 }  // namespace sandbox