Convert some non-debug logging on content/common to debug logging.

content/common/process_watcher_mac.cc

 // Copyright (c) 2009 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 "content/common/process_watcher.h"
 
 #include <errno.h>
 #include <signal.h>
 #include <sys/event.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/time.h"
 
 namespace {
 
 const int kWaitBeforeKillSeconds = 2;
 
 // Reap |child| process. This call blocks until completion.
 void BlockingReap(pid_t child) {
   const pid_t result = HANDLE_EINTR(waitpid(child, NULL, 0));
   if (result == -1) {
-    PLOG(ERROR) << "waitpid(" << child << ", NULL, 0)";
+    DPLOG(ERROR) << "waitpid(" << child << ", NULL, 0)";
   }
 }
 
 // Waits for |timeout| seconds for the given |child| to exit and reap it. If
 // the child doesn't exit within the time specified, kills it.
 //
 // This function takes two approaches: first, it tries to use kqueue to
 // observe when the process exits. kevent can monitor a kqueue with a
 // timeout, so this method is preferred to wait for a specified period of
 // time. Once the kqueue indicates the process has exited, waitpid will reap
@@ skipping 34 matching lines @@
   // DON'T ADD ANY EARLY RETURNS TO THIS FUNCTION without ensuring that
   // |child| has been reaped. Specifically, even if a kqueue, kevent, or other
   // call fails, this function should fall back to the last resort of trying
   // to kill and reap the process. Not observing this rule will resurrect
   // zombies.
 
   int result;
 
   int kq = HANDLE_EINTR(kqueue());
   if (kq == -1) {
-    PLOG(ERROR) << "kqueue()";
+    DPLOG(ERROR) << "kqueue()";
   } else {
     file_util::ScopedFD auto_close_kq(&kq);
 
     struct kevent change = {0};
     EV_SET(&change, child, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
     result = HANDLE_EINTR(kevent(kq, &change, 1, NULL, 0, NULL));
 
     if (result == -1) {
       if (errno != ESRCH) {
-        PLOG(ERROR) << "kevent (setup " << child << ")";
+        DPLOG(ERROR) << "kevent (setup " << child << ")";
       } else {
         // At this point, one of the following has occurred:
         // 1. The process has died but has not yet been reaped.
         // 2. The process has died and has already been reaped.
         // 3. The process is in the process of dying. It's no longer
         //    kqueueable, but it may not be waitable yet either. Mark calls
         //    this case the "zombie death race".
 
         result = HANDLE_EINTR(waitpid(child, NULL, WNOHANG));
 
@@ skipping 21 matching lines @@
         result = kevent(kq, NULL, 0, &event, 1, &remaining_timespec);
         if (result == -1 && errno == EINTR) {
           remaining_delta = deadline - base::Time::Now();
           result = 0;
         } else {
           break;
         }
       }
 
       if (result == -1) {
-        PLOG(ERROR) << "kevent (wait " << child << ")";
+        DPLOG(ERROR) << "kevent (wait " << child << ")";
       } else if (result > 1) {
-        LOG(ERROR) << "kevent (wait " << child << "): unexpected result "
-                   << result;
+        DLOG(ERROR) << "kevent (wait " << child << "): unexpected result "
+                    << result;
       } else if (result == 1) {
         if ((event.fflags & NOTE_EXIT) &&
             (event.ident == static_cast<uintptr_t>(child))) {
           // The process is dead or dying. This won't block for long, if at
           // all.
           BlockingReap(child);
           return;
         } else {
-          LOG(ERROR) << "kevent (wait " << child
-                     << "): unexpected event: fflags=" << event.fflags
-                     << ", ident=" << event.ident;
+          DLOG(ERROR) << "kevent (wait " << child
+                      << "): unexpected event: fflags=" << event.fflags
+                      << ", ident=" << event.ident;
         }
       }
     }
   }
 
   // The child is still alive, or is very freshly dead. Be sure by sending it
   // a signal. This is safe even if it's freshly dead, because it will be a
   // zombie (or on the way to zombiedom) and kill will return 0 even if the
   // signal is not delivered to a live process.
   result = kill(child, SIGKILL);
   if (result == -1) {
-    PLOG(ERROR) << "kill(" << child << ", SIGKILL)";
+    DPLOG(ERROR) << "kill(" << child << ", SIGKILL)";
   } else {
     // The child is definitely on the way out now. BlockingReap won't need to
     // wait for long, if at all.
     BlockingReap(child);
   }
 }
 
 }  // namespace
 
 void ProcessWatcher::EnsureProcessTerminated(base::ProcessHandle process) {
   WaitForChildToDie(process, kWaitBeforeKillSeconds);
 }