Update Linux sandbox tests to pass on Android.

sandbox/linux/seccomp-bpf/sandbox_bpf_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 <sys/syscall.h>
 #include <sys/utsname.h>
 
 #include <ostream>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 433 matching lines @@
 BPF_TEST(SandboxBpf, SigMask, RedirectAllSyscallsPolicy) {
   // Signal masks are potentially tricky to handle. For instance, if we
   // ever tried to update them from inside a Trap() or UnsafeTrap() handler,
   // the call to sigreturn() at the end of the signal handler would undo
   // all of our efforts. So, it makes sense to test that sigprocmask()
   // works, even if we have a policy in place that makes use of UnsafeTrap().
   // In practice, this works because we force sigprocmask() to be handled
   // entirely in the kernel.
   sigset_t mask0, mask1, mask2;
 
-  // Call sigprocmask() to verify that SIGUSR1 wasn't blocked, if we didn't
+  // Call sigprocmask() to verify that SIGUSR2 wasn't blocked, if we didn't
   // change the mask (it shouldn't have been, as it isn't blocked by default
   // in POSIX).
+  //
+  // Use SIGUSR2 because Android seems to use SIGUSR1 for some purpose.
   sigemptyset(&mask0);
   BPF_ASSERT(!sigprocmask(SIG_BLOCK, &mask0, &mask1));
-  BPF_ASSERT(!sigismember(&mask1, SIGUSR1));
+  BPF_ASSERT(!sigismember(&mask1, SIGUSR2));
 
   // Try again, and this time we verify that we can block it. This
   // requires a second call to sigprocmask().
-  sigaddset(&mask0, SIGUSR1);
+  sigaddset(&mask0, SIGUSR2);
   BPF_ASSERT(!sigprocmask(SIG_BLOCK, &mask0, NULL));
   BPF_ASSERT(!sigprocmask(SIG_BLOCK, NULL, &mask2));
-  BPF_ASSERT( sigismember(&mask2, SIGUSR1));
+  BPF_ASSERT( sigismember(&mask2, SIGUSR2));
 }
 
 BPF_TEST(SandboxBpf, UnsafeTrapWithErrno, RedirectAllSyscallsPolicy) {
   // An UnsafeTrap() (or for that matter, a Trap()) has to report error
   // conditions by returning an exit code in the range -1..-4096. This
   // should happen automatically if using ForwardSyscall(). If the TrapFnc()
   // uses some other method to make system calls, then it is responsible
   // for computing the correct return code.
   // This test verifies that ForwardSyscall() does the correct thing.
 
@@ skipping 484 matching lines @@
                DEATH_MESSAGE("Unexpected 64bit argument detected"),
                EqualityWithNegativeArgumentsPolicy) {
   // When expecting a 32bit system call argument, we look at the MSB of the
   // 64bit value and allow both "0" and "-1". But the latter is allowed only
   // iff the LSB was negative. So, this death test should error out.
   BPF_ASSERT(SandboxSyscall(__NR_uname, 0xFFFFFFFF00000000ll) == -1);
 }
 #endif
 
 } // namespace