Update sandbox/linux from upstream

sandbox/linux/services/yama_unittests.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 <errno.h>
 #include <fcntl.h>
 #include <sys/ptrace.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "sandbox/linux/services/scoped_process.h"
 #include "sandbox/linux/services/yama.h"
 #include "sandbox/linux/tests/unit_tests.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sandbox {
 
 namespace {
 
 bool HasLinux32Bug() {
 #if defined(__i386__)
   // On 3.2 kernels, yama doesn't work for 32-bit binaries on 64-bit kernels.
   // This is fixed in 3.4.
   bool is_kernel_64bit =
       base::SysInfo::OperatingSystemArchitecture() == "x86_64";
   bool is_linux = base::SysInfo::OperatingSystemName() == "Linux";
-  bool is_3_dot_2 = StartsWithASCII(
-      base::SysInfo::OperatingSystemVersion(), "3.2", /*case_sensitive=*/false);
+  bool is_3_dot_2 = base::StartsWith(
+      base::SysInfo::OperatingSystemVersion(), "3.2",
+      base::CompareCase::INSENSITIVE_ASCII);
   if (is_kernel_64bit && is_linux && is_3_dot_2)
     return true;
 #endif  // defined(__i386__)
   return false;
 }
 
 bool CanPtrace(pid_t pid) {
   int ret;
   ret = ptrace(PTRACE_ATTACH, pid, NULL, NULL);
   if (ret == -1) {
@@ skipping 99 matching lines @@
     // However, parent can ptrace process1.
     ASSERT_TRUE(CanPtrace(process1.GetPid()));
 
     // A sibling can ptrace process2 which disables any Yama protection.
     ScopedProcess process2(base::Bind(&SetYamaRestrictions, false));
     ASSERT_TRUE(process2.WaitForClosureToRun());
     ASSERT_TRUE(CanSubProcessPtrace(process2.GetPid()));
   }
 }
 
-void DoNothing() {}
-
 SANDBOX_TEST(Yama, RestrictPtraceIsDefault) {
   if (!Yama::IsPresent() || HasLinux32Bug())
     return;
 
   CHECK(Yama::DisableYamaRestrictions());
-  ScopedProcess process1(base::Bind(&DoNothing));
+  ScopedProcess process1(base::Bind(&base::DoNothing));
 
   if (Yama::IsEnforcing()) {
     // Check that process1 is protected by Yama, even though it has
     // been created from a process that disabled Yama.
     CHECK(!CanSubProcessPtrace(process1.GetPid()));
   }
 }
 
 }  // namespace
 
 }  // namespace sandbox