Linux sandbox: change the return type of HandleRequest

sandbox/linux/syscall_broker/broker_process.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/syscall_broker/broker_process.h"
 
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ skipping 10 matching lines @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/process_metrics.h"
 #include "build/build_config.h"
 #include "sandbox/linux/syscall_broker/broker_client.h"
 #include "sandbox/linux/syscall_broker/broker_host.h"
 
 namespace sandbox {
 
+namespace syscall_broker {
+
 BrokerProcess::BrokerProcess(int denied_errno,
                              const std::vector<std::string>& allowed_r_files,
                              const std::vector<std::string>& allowed_w_files,
                              bool fast_check_in_client,
                              bool quiet_failures_for_tests)
     : initialized_(false),
       is_child_(false),
       fast_check_in_client_(fast_check_in_client),
       quiet_failures_for_tests_(quiet_failures_for_tests),
       broker_pid_(-1),
@@ skipping 37 matching lines @@
   }
   if (child_pid) {
     // We are the parent and we have just forked our broker process.
     close(socket_pair[0]);
     // We should only be able to write to the IPC channel. We'll always send
     // a new file descriptor to receive the reply on.
     shutdown(socket_pair[1], SHUT_RD);
     ipc_socketpair_ = socket_pair[1];
     is_child_ = false;
     broker_pid_ = child_pid;
-    broker_client_.reset(
-        new syscall_broker::BrokerClient(policy_,
-                                         ipc_socketpair_,
-                                         fast_check_in_client_,
-                                         quiet_failures_for_tests_));
+    broker_client_.reset(new BrokerClient(policy_, ipc_socketpair_,
+                                          fast_check_in_client_,
+                                          quiet_failures_for_tests_));
     initialized_ = true;
     return true;
   } else {
     // We are the broker.
     close(socket_pair[1]);
     // We should only be able to read from this IPC channel. We will send our
     // replies on a new file descriptor attached to the requests.
     shutdown(socket_pair[0], SHUT_WR);
     ipc_socketpair_ = socket_pair[0];
     is_child_ = true;
     CHECK(broker_process_init_callback.Run());
-    syscall_broker::BrokerHost broker_host(policy_, ipc_socketpair_);
+    BrokerHost broker_host(policy_, ipc_socketpair_);
     initialized_ = true;
     for (;;) {
-      broker_host.HandleRequest();
+      switch (broker_host.HandleRequest()) {
+        case BrokerHost::RequestStatus::LOST_CLIENT:
+          break;
+        case BrokerHost::RequestStatus::SUCCESS:
+        case BrokerHost::RequestStatus::FAILURE:
+          continue;
+      }
     }
     _exit(1);
   }
   NOTREACHED();
 }
 
 int BrokerProcess::Access(const char* pathname, int mode) const {
   RAW_CHECK(initialized_);
   return broker_client_->Access(pathname, mode);
 }
 
 int BrokerProcess::Open(const char* pathname, int flags) const {
   RAW_CHECK(initialized_);
   return broker_client_->Open(pathname, flags);
 }
 
+}  // namespace syscall_broker
+
 }  // namespace sandbox.