Replace most LOG/CHECK statements with DLOG/DCHECK statements in base.

base/linux_util.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 "base/linux_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <glib.h>
@@ skipping 70 matching lines @@
 //   path: e.g. /proc/1234/fd/5 (must be a UNIX domain socket descriptor)
 //   log: if true, log messages about failure details
 bool ProcPathGetInode(ino_t* inode_out, const char* path, bool log = false) {
   DCHECK(inode_out);
   DCHECK(path);
 
   char buf[256];
   const ssize_t n = readlink(path, buf, sizeof(buf) - 1);
   if (n == -1) {
     if (log) {
-      LOG(WARNING) << "Failed to read the inode number for a socket from /proc"
+      DLOG(WARNING) << "Failed to read the inode number for a socket from /proc"
                       "(" << errno << ")";
     }
     return false;
   }
   buf[n] = 0;
 
   if (memcmp(kSocketLinkPrefix, buf, sizeof(kSocketLinkPrefix) - 1)) {
     if (log) {
-      LOG(WARNING) << "The descriptor passed from the crashing process wasn't a"
-                      " UNIX domain socket.";
+      DLOG(WARNING) << "The descriptor passed from the crashing process wasn't "
+                      " a UNIX domain socket.";
     }
     return false;
   }
 
   char *endptr;
   const unsigned long long int inode_ul =
       strtoull(buf + sizeof(kSocketLinkPrefix) - 1, &endptr, 10);
   if (*endptr != ']')
     return false;
 
   if (inode_ul == ULLONG_MAX) {
     if (log) {
-      LOG(WARNING) << "Failed to parse a socket's inode number: the number was "
-                      "too large. Please report this bug: " << buf;
+      DLOG(WARNING) << "Failed to parse a socket's inode number: the number "
+                       "was too large. Please report this bug: " << buf;
     }
     return false;
   }
 
   *inode_out = inode_ul;
   return true;
 }
 
 }  // namespace
 
@@ skipping 68 matching lines @@
   *inode_out = buf.st_ino;
   return true;
 }
 
 bool FindProcessHoldingSocket(pid_t* pid_out, ino_t socket_inode) {
   DCHECK(pid_out);
   bool already_found = false;
 
   DIR* proc = opendir("/proc");
   if (!proc) {
-    LOG(WARNING) << "Cannot open /proc";
+    DLOG(WARNING) << "Cannot open /proc";
     return false;
   }
 
   std::vector<pid_t> pids;
 
   struct dirent* dent;
   while ((dent = readdir(proc))) {
     char *endptr;
     const unsigned long int pid_ul = strtoul(dent->d_name, &endptr, 10);
     if (pid_ul == ULONG_MAX || *endptr)
@@ skipping 41 matching lines @@
 pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data,
                               bool* syscall_supported) {
   char buf[256];
   snprintf(buf, sizeof(buf), "/proc/%d/task", pid);
 
   if (syscall_supported != NULL)
     *syscall_supported = false;
 
   DIR* task = opendir(buf);
   if (!task) {
-    LOG(WARNING) << "Cannot open " << buf;
+    DLOG(WARNING) << "Cannot open " << buf;
     return -1;
   }
 
   std::vector<pid_t> tids;
   struct dirent* dent;
   while ((dent = readdir(task))) {
     char *endptr;
     const unsigned long int tid_ul = strtoul(dent->d_name, &endptr, 10);
     if (tid_ul == ULONG_MAX || *endptr)
       continue;
@@ skipping 19 matching lines @@
 
     if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
                      expected_data.length())) {
       return current_tid;
     }
   }
   return -1;
 }
 
 }  // namespace base