Roll Chrome into Mojo.

sandbox/linux/services/credentials.cc

 // Copyright (c) 2013 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/credentials.h"
 
 #include <errno.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/capability.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/template_util.h"
 #include "base/third_party/valgrind/valgrind.h"
 #include "base/threading/thread.h"
-#include "sandbox/linux/services/proc_util.h"
 #include "sandbox/linux/services/syscall_wrappers.h"
 
 namespace {
 
 bool IsRunningOnValgrind() { return RUNNING_ON_VALGRIND; }
 
 struct CapFreeDeleter {
   inline void operator()(cap_t cap) const {
     int ret = cap_free(cap);
     CHECK_EQ(0, ret);
@@ skipping 17 matching lines @@
   inline void operator()(FILE* f) const {
     DCHECK(f);
     PCHECK(0 == fclose(f));
   }
 };
 
 // Don't use ScopedFILE in base since it doesn't check fclose().
 // TODO(jln): fix base/.
 typedef scoped_ptr<FILE, FILECloser> ScopedFILE;
 
-COMPILE_ASSERT((base::is_same<uid_t, gid_t>::value), UidAndGidAreSameType);
+static_assert((base::is_same<uid_t, gid_t>::value),
+              "uid_t and gid_t should be the same type");
 // generic_id_t can be used for either uid_t or gid_t.
 typedef uid_t generic_id_t;
 
 // Write a uid or gid mapping from |id| to |id| in |map_file|.
 bool WriteToIdMapFile(const char* map_file, generic_id_t id) {
   ScopedFILE f(fopen(map_file, "w"));
   PCHECK(f);
   const uid_t inside_id = id;
   const uid_t outside_id = id;
   int num = fprintf(f.get(), "%d %d 1\n", inside_id, outside_id);
@@ skipping 21 matching lines @@
   if (resuid) *resuid = euid;
   if (resgid) *resgid = egid;
   return true;
 }
 
 // chroot() and chdir() to /proc/<tid>/fdinfo.
 void ChrootToThreadFdInfo(base::PlatformThreadId tid, bool* result) {
   DCHECK(result);
   *result = false;
 
-  COMPILE_ASSERT((base::is_same<base::PlatformThreadId, int>::value),
-                 TidIsAnInt);
+  static_assert((base::is_same<base::PlatformThreadId, int>::value),
+                "platform thread id should be an int");
   const std::string current_thread_fdinfo = "/proc/" +
       base::IntToString(tid) + "/fdinfo/";
 
   // Make extra sure that /proc/<tid>/fdinfo is unique to the thread.
   CHECK(0 == unshare(CLONE_FILES));
   int chroot_ret = chroot(current_thread_fdinfo.c_str());
   if (chroot_ret) {
     PLOG(ERROR) << "Could not chroot";
     return;
   }
@@ skipping 125 matching lines @@
   DCHECK(GetRESIds(NULL, NULL));
   const char kGidMapFile[] = "/proc/self/gid_map";
   const char kUidMapFile[] = "/proc/self/uid_map";
   CHECK(WriteToIdMapFile(kGidMapFile, gid));
   CHECK(WriteToIdMapFile(kUidMapFile, uid));
   DCHECK(GetRESIds(NULL, NULL));
   return true;
 }
 
 bool Credentials::DropFileSystemAccess() {
-  // Chrooting to a safe empty dir will only be safe if no directory file
-  // descriptor is available to the process.
-  DCHECK(!ProcUtil::HasOpenDirectory(-1));
   return ChrootToSafeEmptyDir();
 }
 
 }  // namespace sandbox.