Implement '--gpu-sandbox-failures-nonfatal' flag.

content/common/sandbox_linux/sandbox_linux.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 <dirent.h>
 #include <fcntl.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ skipping 61 matching lines @@
 }
 
 bool IsRunningTSAN() {
 #if defined(THREAD_SANITIZER)
   return true;
 #else
   return false;
 #endif
 }
 
+bool IsChromeOS() {
+#if defined(OS_CHROMEOS)
+  return true;
+#else
+  return false;
+#endif
+}
+
 // Try to open /proc/self/task/ with the help of |proc_fd|. |proc_fd| can be
 // -1. Will return -1 on error and set errno like open(2).
 int OpenProcTaskFd(int proc_fd) {
   int proc_self_task = -1;
   if (proc_fd >= 0) {
     // If a handle to /proc is available, use it. This allows to bypass file
     // system restrictions.
     proc_self_task = openat(proc_fd, "self/task/", O_RDONLY | O_DIRECTORY);
   } else {
     // Otherwise, make an attempt to access the file system directly.
@@ skipping 137 matching lines @@
   if (seccomp_bpf_supported())
     seccomp_bpf_started_ = SandboxSeccompBPF::StartSandbox(process_type);
 
   if (seccomp_bpf_started_)
     LogSandboxStarted("seccomp-bpf");
 
   return seccomp_bpf_started_;
 }
 
 bool LinuxSandbox::InitializeSandboxImpl() {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
   const std::string process_type =
-      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kProcessType);
+      command_line->GetSwitchValueASCII(switches::kProcessType);
 
   // We need to make absolutely sure that our sandbox is "sealed" before
   // returning.
   // Unretained() since the current object is a Singleton.
   base::ScopedClosureRunner sandbox_sealer(
       base::Bind(&LinuxSandbox::SealSandbox, base::Unretained(this)));
   // Make sure that this function enables sandboxes as promised by GetStatus().
   // Unretained() since the current object is a Singleton.
   base::ScopedClosureRunner sandbox_promise_keeper(
       base::Bind(&LinuxSandbox::CheckForBrokenPromises,
                  base::Unretained(this),
                  process_type));
 
   // No matter what, it's always an error to call InitializeSandbox() after
   // threads have been created.
   if (!IsSingleThreaded()) {
     std::string error_message = "InitializeSandbox() called with multiple "
                                 "threads in process " + process_type;
     // TSAN starts a helper thread. So we don't start the sandbox and don't
     // even report an error about it.
     if (IsRunningTSAN())
       return false;
-    // The GPU process is allowed to call InitializeSandbox() with threads for
-    // now, because it loads third-party libraries.
-    if (process_type != switches::kGpuProcess)
-      CHECK(false) << error_message;
+
+    // The GPU process is allowed to call InitializeSandbox() with threads.
+    bool sandbox_failure_fatal = process_type != switches::kGpuProcess;
+
+    // On Chrome OS, the GPU process is only allowed to call InitializeSandbox()
+    // with threads if '--gpu-sandbox-failures-nonfatal' is passed.
+    if (IsChromeOS()) {
+      sandbox_failure_fatal |=
+          !command_line->HasSwitch(switches::kGpuSandboxFailuresNonfatal);
+    }
+
+    if (sandbox_failure_fatal)
+      LOG(FATAL) << error_message;
+
     LOG(ERROR) << error_message;
     return false;
   }
 
   // Only one thread is running, pre-initialize if not already done.
   if (!pre_initialized_)
     PreinitializeSandbox();
 
   DCHECK(!HasOpenDirectories()) <<
       "InitializeSandbox() called after unexpected directories have been " <<
@@ skipping 88 matching lines @@
 void LinuxSandbox::StopThreadAndEnsureNotCounted(base::Thread* thread) const {
   DCHECK(thread);
   int proc_self_task = OpenProcTaskFd(proc_fd_);
   PCHECK(proc_self_task >= 0);
   SafeScopedFD task_closer(&proc_self_task);
   CHECK(
       sandbox::ThreadHelpers::StopThreadAndWatchProcFS(proc_self_task, thread));
 }
 
 }  // namespace content