Cleanup: Remove the C version of GetUrandomFD()

content/zygote/zygote_main_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 <dlfcn.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/hash_tables.h"
 #include "base/linux_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
-#include "base/rand_util_c.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "content/common/font_config_ipc_linux.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/sandbox_methods_linux.h"
 #include "content/common/seccomp_sandbox.h"
 #include "content/common/unix_domain_socket_posix.h"
 #include "content/common/zygote_commands_linux.h"
 #include "content/public/common/content_switches.h"
@@ skipping 297 matching lines @@
 // means that we cannot override fopen() directly here. Instead the
 // the code below defines fopen_override() function with asm name
 // "fopen", so that all references to fopen() will resolve to this
 // function.
 __attribute__ ((__visibility__("default")))
 FILE* fopen_override(const char* path, const char* mode)  __asm__ ("fopen");
 
 __attribute__ ((__visibility__("default")))
 FILE* fopen_override(const char* path, const char* mode) {
   if (g_am_zygote_or_renderer && strcmp(path, kUrandomDevPath) == 0) {
-    int fd = HANDLE_EINTR(dup(GetUrandomFD()));
+    int fd = HANDLE_EINTR(dup(base::GetUrandomFD()));
     if (fd < 0) {
       PLOG(ERROR) << "dup() failed.";
       return NULL;
     }
     return fdopen(fd, mode);
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_file_io_funcs_guard,
                              InitLibcFileIOFunctions));
     return g_libc_fopen(path, mode);
   }
 }
 
 __attribute__ ((__visibility__("default")))
 FILE* fopen64(const char* path, const char* mode) {
   if (g_am_zygote_or_renderer && strcmp(path, kUrandomDevPath) == 0) {
-    int fd = HANDLE_EINTR(dup(GetUrandomFD()));
+    int fd = HANDLE_EINTR(dup(base::GetUrandomFD()));
     if (fd < 0) {
       PLOG(ERROR) << "dup() failed.";
       return NULL;
     }
     return fdopen(fd, mode);
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_file_io_funcs_guard,
                              InitLibcFileIOFunctions));
     return g_libc_fopen64(path, mode);
   }
 }
 
 // stat() is subject to the same problem as fopen(), so we have to use
 // the same trick to override it.
 __attribute__ ((__visibility__("default")))
 int xstat_override(int version,
                    const char *path,
                    struct stat *buf)  __asm__ ("__xstat");
 
 __attribute__ ((__visibility__("default")))
 int xstat_override(int version, const char *path, struct stat *buf) {
   if (g_am_zygote_or_renderer && strcmp(path, kUrandomDevPath) == 0) {
-    int result = __fxstat(version, GetUrandomFD(), buf);
+    int result = __fxstat(version, base::GetUrandomFD(), buf);
     return result;
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_file_io_funcs_guard,
                              InitLibcFileIOFunctions));
     return g_libc_xstat(version, path, buf);
   }
 }
 
 __attribute__ ((__visibility__("default")))
 int xstat64_override(int version,
                      const char *path,
                      struct stat64 *buf)  __asm__ ("__xstat64");
 
 __attribute__ ((__visibility__("default")))
 int xstat64_override(int version, const char *path, struct stat64 *buf) {
   if (g_am_zygote_or_renderer && strcmp(path, kUrandomDevPath) == 0) {
-    int result = __fxstat64(version, GetUrandomFD(), buf);
+    int result = __fxstat64(version, base::GetUrandomFD(), buf);
     return result;
   } else {
     CHECK_EQ(0, pthread_once(&g_libc_file_io_funcs_guard,
                              InitLibcFileIOFunctions));
     CHECK(g_libc_xstat64);
     return g_libc_xstat64(version, path, buf);
   }
 }
 
 #endif  // !ADDRESS_SANITIZER
@@ skipping 278 matching lines @@
     }
   }
 #endif  // SECCOMP_SANDBOX
 
   Zygote zygote(sandbox_flags, forkdelegate, proc_fd_for_seccomp);
   // This function call can return multiple times, once per fork().
   return zygote.ProcessRequests();
 }
 
 }  // namespace content