Clarify the process title of GPU broker process.

sandbox/linux/services/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 <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "sandbox/linux/tests/unit_tests.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using file_util::ScopedFD;
 
 namespace sandbox {
@@ skipping 25 matching lines @@
 
   int fd() const { return fd_; }
   const char* full_file_name() const { return full_file_name_; }
 
  private:
   int fd_;
   char full_file_name_[128];
   DISALLOW_COPY_AND_ASSIGN(ScopedTemporaryFile);
 };
 
+bool NoOpCallback() { return true; }
+
 }  // namespace
 
 #if defined(OS_ANDROID)
   #define DISABLE_ON_ANDROID(function) DISABLED_##function
 #else
   #define DISABLE_ON_ANDROID(function) function
 #endif
 
 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(NULL));
+  ASSERT_TRUE(open_broker->Init(base::Bind(&NoOpCallback)));
   pid_t broker_pid = open_broker->broker_pid();
 
   // Destroy the broker and check it has exited properly.
   open_broker.reset();
   int status = 0;
   ASSERT_EQ(waitpid(broker_pid, &status, 0), broker_pid);
   ASSERT_TRUE(WIFEXITED(status));
   ASSERT_EQ(WEXITSTATUS(status), 0);
 }
 
 TEST(BrokerProcess, TestOpenAccessNull) {
   const std::vector<std::string> empty;
   BrokerProcess open_broker(EPERM, empty, empty);
-  ASSERT_TRUE(open_broker.Init(NULL));
+  ASSERT_TRUE(open_broker.Init(base::Bind(&NoOpCallback)));
 
   int fd = open_broker.Open(NULL, O_RDONLY);
   ASSERT_EQ(fd, -EFAULT);
 
   int ret = open_broker.Access(NULL, F_OK);
   ASSERT_EQ(ret, -EFAULT);
 }
 
 void TestOpenFilePerms(bool fast_check_in_client, int denied_errno) {
   const char kR_WhiteListed[] = "/proc/DOESNOTEXIST1";
@@ skipping 10 matching lines @@
   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);
-  ASSERT_TRUE(open_broker.Init(NULL));
+  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;
   ret = open_broker.Access(kR_WhiteListed, F_OK);
@@ skipping 130 matching lines @@
   // expected.
 }
 
 void TestOpenCpuinfo(bool fast_check_in_client) {
   const char kFileCpuInfo[] = "/proc/cpuinfo";
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back(kFileCpuInfo);
 
   scoped_ptr<BrokerProcess> open_broker(new BrokerProcess(
       EPERM, read_whitelist, std::vector<std::string>(), fast_check_in_client));
-  ASSERT_TRUE(open_broker->Init(NULL));
+  ASSERT_TRUE(open_broker->Init(base::Bind(&NoOpCallback)));
   pid_t broker_pid = open_broker->broker_pid();
 
   int fd = -1;
   fd = open_broker->Open(kFileCpuInfo, O_RDWR);
   ScopedFD fd_closer(&fd);
   ASSERT_EQ(fd, -EPERM);
 
   // Check we can read /proc/cpuinfo.
   int can_access = open_broker->Access(kFileCpuInfo, R_OK);
   ASSERT_EQ(can_access, 0);
@@ skipping 49 matching lines @@
 }
 
 TEST(BrokerProcess, OpenFileRW) {
   ScopedTemporaryFile tempfile;
   const char* tempfile_name = tempfile.full_file_name();
 
   std::vector<std::string> whitelist;
   whitelist.push_back(tempfile_name);
 
   BrokerProcess open_broker(EPERM, whitelist, whitelist);
-  ASSERT_TRUE(open_broker.Init(NULL));
+  ASSERT_TRUE(open_broker.Init(base::Bind(&NoOpCallback)));
 
   // Check we can access that file with read or write.
   int can_access = open_broker.Access(tempfile_name, R_OK | W_OK);
   ASSERT_EQ(can_access, 0);
 
   int tempfile2 = -1;
   tempfile2 = open_broker.Open(tempfile_name, O_RDWR);
   ASSERT_GE(tempfile2, 0);
 
   // Write to the descriptor opened by the broker.
@@ skipping 16 matching lines @@
 // and we want this to happen in a subprocess.
 SANDBOX_TEST(BrokerProcess, BrokerDied) {
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back("/proc/cpuinfo");
 
   BrokerProcess open_broker(EPERM,
                             read_whitelist,
                             std::vector<std::string>(),
                             true /* fast_check_in_client */,
                             true /* quiet_failures_for_tests */);
-  SANDBOX_ASSERT(open_broker.Init(NULL));
+  SANDBOX_ASSERT(open_broker.Init(base::Bind(&NoOpCallback)));
   pid_t broker_pid = open_broker.broker_pid();
   SANDBOX_ASSERT(kill(broker_pid, SIGKILL) == 0);
 
   // Now we check that the broker has exited properly.
   int status = 0;
   SANDBOX_ASSERT(waitpid(broker_pid, &status, 0) == broker_pid);
   SANDBOX_ASSERT(WIFSIGNALED(status));
   SANDBOX_ASSERT(WTERMSIG(status) == SIGKILL);
   // 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);
-  ASSERT_TRUE(open_broker.Init(NULL));
+  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));
   ASSERT_EQ(0, close(fd));
@@ skipping 21 matching lines @@
   // expected.
 }
 
 TEST(BrokerProcess, OpenComplexFlagsNoClientCheck) {
   TestOpenComplexFlags(false /* fast_check_in_client */);
   // Don't do anything here, so that ASSERT works in the subfunction as
   // expected.
 }
 
 }  // namespace sandbox