Replace most LOG statements with DLOG statements in base.

base/process_util_linux.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 66 matching lines @@
 // on success or -1 on error.
 int GetProcessCPU(pid_t pid) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Use /proc/<pid>/task to find all threads and parse their /stat file.
   FilePath path = FilePath(base::StringPrintf("/proc/%d/task/", pid));
 
   DIR* dir = opendir(path.value().c_str());
   if (!dir) {
-    PLOG(ERROR) << "opendir(" << path.value() << ")";
+    DPLOG(ERROR) << "opendir(" << path.value() << ")";
     return -1;
   }
 
   int total_cpu = 0;
   while (struct dirent* ent = readdir(dir)) {
     if (ent->d_name[0] == '.')
       continue;
 
     FilePath stat_path = path.AppendASCII(ent->d_name).AppendASCII("stat");
     std::string stat;
@@ skipping 168 matching lines @@
 
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
   return new ProcessMetrics(process);
 }
 
 // On linux, we return vsize.
 size_t ProcessMetrics::GetPagefileUsage() const {
   std::vector<std::string> proc_stats;
   if (!GetProcStats(process_, &proc_stats))
-    LOG(WARNING) << "Failed to get process stats.";
+    DLOG(WARNING) << "Failed to get process stats.";
   const size_t kVmSize = 22;
   if (proc_stats.size() > kVmSize) {
     int vm_size;
     base::StringToInt(proc_stats[kVmSize], &vm_size);
     return static_cast<size_t>(vm_size);
   }
   return 0;
 }
 
 // On linux, we return the high water mark of vsize.
 size_t ProcessMetrics::GetPeakPagefileUsage() const {
   std::vector<std::string> proc_stats;
   if (!GetProcStats(process_, &proc_stats))
-    LOG(WARNING) << "Failed to get process stats.";
+    DLOG(WARNING) << "Failed to get process stats.";
   const size_t kVmPeak = 21;
   if (proc_stats.size() > kVmPeak) {
     int vm_peak;
     if (base::StringToInt(proc_stats[kVmPeak], &vm_peak))
       return vm_peak;
   }
   return 0;
 }
 
 // On linux, we return RSS.
 size_t ProcessMetrics::GetWorkingSetSize() const {
   std::vector<std::string> proc_stats;
   if (!GetProcStats(process_, &proc_stats))
-    LOG(WARNING) << "Failed to get process stats.";
+    DLOG(WARNING) << "Failed to get process stats.";
   const size_t kVmRss = 23;
   if (proc_stats.size() > kVmRss) {
     int num_pages;
     if (base::StringToInt(proc_stats[kVmRss], &num_pages))
       return static_cast<size_t>(num_pages) * getpagesize();
   }
   return 0;
 }
 
 // On linux, we return the high water mark of RSS.
 size_t ProcessMetrics::GetPeakWorkingSetSize() const {
   std::vector<std::string> proc_stats;
   if (!GetProcStats(process_, &proc_stats))
-    LOG(WARNING) << "Failed to get process stats.";
+    DLOG(WARNING) << "Failed to get process stats.";
   const size_t kVmHwm = 23;
   if (proc_stats.size() > kVmHwm) {
     int num_pages;
     base::StringToInt(proc_stats[kVmHwm], &num_pages);
     return static_cast<size_t>(num_pages) * getpagesize();
   }
   return 0;
 }
 
 bool ProcessMetrics::GetMemoryBytes(size_t* private_bytes,
@@ skipping 240 matching lines @@
 }  // namespace
 
 bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Used memory is: total - free - buffers - caches
   FilePath meminfo_file("/proc/meminfo");
   std::string meminfo_data;
   if (!file_util::ReadFileToString(meminfo_file, &meminfo_data)) {
-    LOG(WARNING) << "Failed to open /proc/meminfo.";
+    DLOG(WARNING) << "Failed to open /proc/meminfo.";
     return false;
   }
   std::vector<std::string> meminfo_fields;
   SplitStringAlongWhitespace(meminfo_data, &meminfo_fields);
 
   if (meminfo_fields.size() < kMemCachedIndex) {
-    LOG(WARNING) << "Failed to parse /proc/meminfo.  Only found " <<
+    DLOG(WARNING) << "Failed to parse /proc/meminfo.  Only found " <<
       meminfo_fields.size() << " fields.";
     return false;
   }
 
   DCHECK_EQ(meminfo_fields[kMemTotalIndex-1], "MemTotal:");
   DCHECK_EQ(meminfo_fields[kMemFreeIndex-1], "MemFree:");
   DCHECK_EQ(meminfo_fields[kMemBuffersIndex-1], "Buffers:");
   DCHECK_EQ(meminfo_fields[kMemCachedIndex-1], "Cached:");
   DCHECK_EQ(meminfo_fields[kMemActiveAnonIndex-1], "Active(anon):");
   DCHECK_EQ(meminfo_fields[kMemInactiveAnonIndex-1], "Inactive(anon):");
@@ skipping 148 matching lines @@
   if (score < 0 || score > kMaxOomScore)
     return false;
 
   FilePath oom_path("/proc");
   oom_path = oom_path.Append(base::Int64ToString(process));
 
   // Attempt to write the newer oom_score_adj file first.
   FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
   if (file_util::PathExists(oom_file)) {
     std::string score_str = base::IntToString(score);
-    VLOG(1) << "Adjusting oom_score_adj of " << process << " to " << score_str;
+    DVLOG(1) << "Adjusting oom_score_adj of " << process << " to "
+             << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   // If the oom_score_adj file doesn't exist, then we write the old
   // style file and translate the oom_adj score to the range 0-15.
   oom_file = oom_path.AppendASCII("oom_adj");
   if (file_util::PathExists(oom_file)) {
     std::string score_str = base::IntToString(
         score * kMaxOldOomScore / kMaxOomScore);
-    VLOG(1) << "Adjusting oom_adj of " << process << " to " << score_str;
+    DVLOG(1) << "Adjusting oom_adj of " << process << " to " << score_str;
     int score_len = static_cast<int>(score_str.length());
     return (score_len == file_util::WriteFile(oom_file,
                                               score_str.c_str(),
                                               score_len));
   }
 
   return false;
 }
 
 }  // namespace base