Replace most LOG statements with DLOG statements in base.

base/process_util_openbsd.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/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 46 matching lines @@
   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, getuid(),
                 sizeof(struct kinfo_proc), 0 };
 
   bool done = false;
   int try_num = 1;
   const int max_tries = 10;
 
   do {
     size_t len = 0;
     if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
-      LOG(ERROR) << "failed to get the size needed for the process list";
+      DLOG(ERROR) << "failed to get the size needed for the process list";
       kinfo_procs_.resize(0);
       done = true;
     } else {
       size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
       // Leave some spare room for process table growth (more could show up
       // between when we check and now)
       num_of_kinfo_proc += 16;
       kinfo_procs_.resize(num_of_kinfo_proc);
       len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
       if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
         // If we get a mem error, it just means we need a bigger buffer, so
         // loop around again.  Anything else is a real error and give up.
         if (errno != ENOMEM) {
-          LOG(ERROR) << "failed to get the process list";
+          DLOG(ERROR) << "failed to get the process list";
           kinfo_procs_.resize(0);
           done = true;
         }
       } else {
         // Got the list, just make sure we're sized exactly right
         size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
         kinfo_procs_.resize(num_of_kinfo_proc);
         done = true;
       }
     }
   } while (!done && (try_num++ < max_tries));
 
   if (!done) {
-    LOG(ERROR) << "failed to collect the process list in a few tries";
+    DDLOG(ERROR) << "failed to collect the process list in a few tries";
     kinfo_procs_.resize(0);
   }
 }
 
 ProcessIterator::~ProcessIterator() {
 }
 
 bool ProcessIterator::CheckForNextProcess() {
   std::string data;
   for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
@@ skipping 24 matching lines @@
     // |entry_.cmd_line_args_|.
     std::string delimiters;
     delimiters.push_back('\0');
     Tokenize(data, delimiters, &entry_.cmd_line_args_);
 
     // |data| starts with the full executable path followed by a null character.
     // We search for the first instance of '\0' and extract everything before it
     // to populate |entry_.exe_file_|.
     size_t exec_name_end = data.find('\0');
     if (exec_name_end == std::string::npos) {
-      LOG(ERROR) << "command line data didn't match expected format";
+      DLOG(ERROR) << "command line data didn't match expected format";
       continue;
     }
 
     entry_.pid_ = kinfo.p_pid;
     entry_.ppid_ = kinfo.p_ppid;
     entry_.gid_ = kinfo.p__pgid;
     size_t last_slash = data.rfind('/', exec_name_end);
     if (last_slash == std::string::npos)
       entry_.exe_file_.assign(data, 0, exec_name_end);
     else
@@ skipping 171 matching lines @@
   return mem_total - (mem_free*pagesize) - (mem_inactive*pagesize);
 }
 
 void EnableTerminationOnOutOfMemory() {
 }
 
 void EnableTerminationOnHeapCorruption() {
 }
 
 }  // namespace base