Replace most LOG statements with DLOG statements in base.

base/process_util_posix.cc

 // Copyright (c) 2011 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 <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 113 matching lines @@
 
   return status;
 }
 
 // Android has built-in crash handling.
 #if !defined(OS_ANDROID)
 void StackDumpSignalHandler(int signal, siginfo_t* info, ucontext_t* context) {
   if (debug::BeingDebugged())
     debug::BreakDebugger();
 
-  LOG(ERROR) << "Received signal " << signal;
+  DLOG(ERROR) << "Received signal " << signal;
   debug::StackTrace().PrintBacktrace();
 
   // TODO(shess): Port to Linux.
 #if defined(OS_MACOSX)
   // TODO(shess): Port to 64-bit.
 #if ARCH_CPU_32_BITS
   char buf[1024];
   size_t len;
 
   // NOTE: Even |snprintf()| is not on the approved list for signal
@@ skipping 144 matching lines @@
 
   if (!result)
     DPLOG(ERROR) << "Unable to terminate process " << process_id;
 
   return result;
 }
 
 bool KillProcessGroup(ProcessHandle process_group_id) {
   bool result = kill(-1 * process_group_id, SIGKILL) == 0;
   if (!result)
-    PLOG(ERROR) << "Unable to terminate process group " << process_group_id;
+    DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
   return result;
 }
 
 // A class to handle auto-closing of DIR*'s.
 class ScopedDIRClose {
  public:
   inline void operator()(DIR* x) const {
     if (x) {
       closedir(x);
     }
@@ skipping 248 matching lines @@
 #if defined(OS_MACOSX)
   int synchronization_pipe_fds[2];
   file_util::ScopedFD synchronization_read_fd;
   file_util::ScopedFD synchronization_write_fd;
 
   if (options.synchronize) {
     // wait means "don't return from LaunchProcess until the child exits", and
     // synchronize means "return from LaunchProcess but don't let the child
     // run until LaunchSynchronize is called". These two options are highly
     // incompatible.
-    CHECK(!options.wait);
+    DCHECK(!options.wait);
 
     // Create the pipe used for synchronization.
     if (HANDLE_EINTR(pipe(synchronization_pipe_fds)) != 0) {
-      PLOG(ERROR) << "pipe";
+      DPLOG(ERROR) << "pipe";
       return false;
     }
 
     // The parent process will only use synchronization_write_fd as the write
     // side of the pipe. It can close the read side as soon as the child
     // process has forked off. The child process will only use
     // synchronization_read_fd as the read side of the pipe. In that process,
     // the write side can be closed as soon as it has forked.
     synchronization_read_fd.reset(&synchronization_pipe_fds[0]);
     synchronization_write_fd.reset(&synchronization_pipe_fds[1]);
   }
 #endif  // OS_MACOSX
 
   pid_t pid;
 #if defined(OS_LINUX)
   if (options.clone_flags) {
     pid = syscall(__NR_clone, options.clone_flags, 0, 0, 0);
   } else
 #endif
   {
     pid = fork();
   }
 
   if (pid < 0) {
-    PLOG(ERROR) << "fork";
+    DPLOG(ERROR) << "fork";
     return false;
   } else if (pid == 0) {
     // Child process
 
     // DANGER: fork() rule: in the child, if you don't end up doing exec*(),
     // you call _exit() instead of exit(). This is because _exit() does not
     // call any previously-registered (in the parent) exit handlers, which
     // might do things like block waiting for threads that don't even exist
     // in the child.
 
@@ skipping 134 matching lines @@
 }
 
 #if defined(OS_MACOSX)
 void LaunchSynchronize(LaunchSynchronizationHandle handle) {
   int synchronization_fd = *handle;
   file_util::ScopedFD synchronization_fd_closer(&synchronization_fd);
   delete handle;
 
   // Write a '\0' character to the pipe.
   if (HANDLE_EINTR(write(synchronization_fd, "", 1)) != 1) {
-    PLOG(ERROR) << "write";
+    DPLOG(ERROR) << "write";
   }
 }
 #endif  // defined(OS_MACOSX)
 
 ProcessMetrics::~ProcessMetrics() { }
 
 bool EnableInProcessStackDumping() {
   // When running in an application, our code typically expects SIGPIPE
   // to be ignored.  Therefore, when testing that same code, it should run
   // with SIGPIPE ignored as well.
@@ skipping 19 matching lines @@
 
 void RaiseProcessToHighPriority() {
   // On POSIX, we don't actually do anything here.  We could try to nice() or
   // setpriority() or sched_getscheduler, but these all require extra rights.
 }
 
 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
   int status = 0;
   const pid_t result = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
   if (result == -1) {
-    PLOG(ERROR) << "waitpid(" << handle << ")";
+    DPLOG(ERROR) << "waitpid(" << handle << ")";
     if (exit_code)
       *exit_code = 0;
     return TERMINATION_STATUS_NORMAL_TERMINATION;
   } else if (result == 0) {
     // the child hasn't exited yet.
     if (exit_code)
       *exit_code = 0;
     return TERMINATION_STATUS_STILL_RUNNING;
   }
 
@@ skipping 64 matching lines @@
 // Using kqueue on Mac so that we can wait on non-child processes.
 // We can't use kqueues on child processes because we need to reap
 // our own children using wait.
 static bool WaitForSingleNonChildProcess(ProcessHandle handle,
                                          int64 wait_milliseconds) {
   DCHECK_GT(handle, 0);
   DCHECK(wait_milliseconds == base::kNoTimeout || wait_milliseconds > 0);
 
   int kq = kqueue();
   if (kq == -1) {
-    PLOG(ERROR) << "kqueue";
+    DPLOG(ERROR) << "kqueue";
     return false;
   }
   file_util::ScopedFD kq_closer(&kq);
 
   struct kevent change = {0};
   EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
   int result = HANDLE_EINTR(kevent(kq, &change, 1, NULL, 0, NULL));
   if (result == -1) {
     if (errno == ESRCH) {
       // If the process wasn't found, it must be dead.
       return true;
     }
 
-    PLOG(ERROR) << "kevent (setup " << handle << ")";
+    DPLOG(ERROR) << "kevent (setup " << handle << ")";
     return false;
   }
 
   // Keep track of the elapsed time to be able to restart kevent if it's
   // interrupted.
   bool wait_forever = wait_milliseconds == base::kNoTimeout;
   base::TimeDelta remaining_delta;
   base::Time deadline;
   if (!wait_forever) {
     remaining_delta = base::TimeDelta::FromMilliseconds(wait_milliseconds);
@@ skipping 19 matching lines @@
       if (!wait_forever) {
         remaining_delta = deadline - base::Time::Now();
       }
       result = 0;
     } else {
       break;
     }
   }
 
   if (result < 0) {
-    PLOG(ERROR) << "kevent (wait " << handle << ")";
+    DPLOG(ERROR) << "kevent (wait " << handle << ")";
     return false;
   } else if (result > 1) {
-    LOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
-               << result;
+    DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
+                << result;
     return false;
   } else if (result == 0) {
     // Timed out.
     return false;
   }
 
   DCHECK_EQ(result, 1);
 
   if (event.filter != EVFILT_PROC ||
       (event.fflags & NOTE_EXIT) == 0 ||
       event.ident != static_cast<uintptr_t>(handle)) {
-    LOG(ERROR) << "kevent (wait " << handle
-               << "): unexpected event: filter=" << event.filter
-               << ", fflags=" << event.fflags
-               << ", ident=" << event.ident;
+    DLOG(ERROR) << "kevent (wait " << handle
+                << "): unexpected event: filter=" << event.filter
+                << ", fflags=" << event.fflags
+                << ", ident=" << event.ident;
     return false;
   }
 
   return true;
 }
 #endif  // OS_MACOSX
 
 bool WaitForSingleProcess(ProcessHandle handle, int64 wait_milliseconds) {
   ProcessHandle parent_pid = GetParentProcessId(handle);
   ProcessHandle our_pid = Process::Current().handle();
@@ skipping 225 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                              filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base