Replace most LOG statements with DLOG statements in base.

base/process_util_mac.mm

 // 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"
 
 #import <Cocoa/Cocoa.h>
 #include <crt_externs.h>
 #include <dlfcn.h>
 #include <mach/mach.h>
@@ skipping 57 matching lines @@
 
   // Since more processes could start between when we get the size and when
   // we get the list, we do a loop to keep trying until we get it.
   bool done = false;
   int try_num = 1;
   const int max_tries = 10;
   do {
     // Get the size of the buffer
     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);
       // Load the list of processes
       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";
+    DLOG(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.kp_proc.p_pid;
     entry_.ppid_ = kinfo.kp_eproc.e_ppid;
     entry_.gid_ = kinfo.kp_eproc.e_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 78 matching lines @@
 }
 
 static bool GetCPUTypeForProcess(pid_t pid, cpu_type_t* cpu_type) {
   size_t len = sizeof(*cpu_type);
   int result = sysctlbyname("sysctl.proc_cputype",
                             cpu_type,
                             &len,
                             NULL,
                             0);
   if (result != 0) {
-    PLOG(ERROR) << "sysctlbyname(""sysctl.proc_cputype"")";
+    DPLOG(ERROR) << "sysctlbyname(""sysctl.proc_cputype"")";
     return false;
   }
 
   return true;
 }
 
 static bool IsAddressInSharedRegion(mach_vm_address_t addr, cpu_type_t type) {
   if (type == CPU_TYPE_I386)
     return addr >= SHARED_REGION_BASE_I386 &&
            addr < (SHARED_REGION_BASE_I386 + SHARED_REGION_SIZE_I386);
@@ skipping 11 matching lines @@
                                     size_t* shared_bytes) {
   kern_return_t kr;
   size_t private_pages_count = 0;
   size_t shared_pages_count = 0;
 
   if (!private_bytes && !shared_bytes)
     return true;
 
   mach_port_t task = TaskForPid(process_);
   if (task == MACH_PORT_NULL) {
-    LOG(ERROR) << "Invalid process";
+    DLOG(ERROR) << "Invalid process";
     return false;
   }
 
   cpu_type_t cpu_type;
   if (!GetCPUTypeForProcess(process_, &cpu_type))
     return false;
 
   // The same region can be referenced multiple times. To avoid double counting
   // we need to keep track of which regions we've already counted.
   base::hash_set<int> seen_objects;
@@ skipping 18 matching lines @@
                         &address,
                         &size,
                         VM_REGION_TOP_INFO,
                         (vm_region_info_t)&info,
                         &info_count,
                         &object_name);
     if (kr == KERN_INVALID_ADDRESS) {
       // We're at the end of the address space.
       break;
     } else if (kr != KERN_SUCCESS) {
-      LOG(ERROR) << "Calling mach_vm_region failed with error: "
+      DLOG(ERROR) << "Calling mach_vm_region failed with error: "
                  << mach_error_string(kr);
       return false;
     }
 
     if (IsAddressInSharedRegion(address, cpu_type) &&
         info.share_mode != SM_PRIVATE)
       continue;
 
     if (info.share_mode == SM_COW && info.ref_count == 1)
       info.share_mode = SM_PRIVATE;
@@ skipping 14 matching lines @@
         }
         break;
       default:
         break;
     }
   }
 
   vm_size_t page_size;
   kr = host_page_size(task, &page_size);
   if (kr != KERN_SUCCESS) {
-    LOG(ERROR) << "Failed to fetch host page size, error: "
+    DLOG(ERROR) << "Failed to fetch host page size, error: "
                << mach_error_string(kr);
     return false;
   }
 
   if (private_bytes)
     *private_bytes = private_pages_count * page_size;
   if (shared_bytes)
     *shared_bytes = shared_pages_count * page_size;
 
   return true;
@@ skipping 97 matching lines @@
 
 // Bytes committed by the system.
 size_t GetSystemCommitCharge() {
   host_name_port_t host = mach_host_self();
   mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
   vm_statistics_data_t data;
   kern_return_t kr = host_statistics(host, HOST_VM_INFO,
                                      reinterpret_cast<host_info_t>(&data),
                                      &count);
   if (kr) {
-    LOG(WARNING) << "Failed to fetch host statistics.";
+    DLOG(WARNING) << "Failed to fetch host statistics.";
     return 0;
   }
 
   vm_size_t page_size;
   kr = host_page_size(host, &page_size);
   if (kr) {
-    LOG(ERROR) << "Failed to fetch host page size.";
+    DLOG(ERROR) << "Failed to fetch host page size.";
     return 0;
   }
 
   return (data.active_count * page_size) / 1024;
 }
 
 namespace {
 
 // Finds the library path for malloc() and thus the libC part of libSystem,
 // which in Lion is in a separate image.
 const char* LookUpLibCPath() {
   const void* addr = reinterpret_cast<void*>(&malloc);
 
   Dl_info info;
   if (dladdr(addr, &info))
     return info.dli_fname;
 
-  LOG(WARNING) << "Could not find image path for malloc()";
+  DLOG(WARNING) << "Could not find image path for malloc()";
   return NULL;
 }
 
 typedef void(*malloc_error_break_t)(void);
 malloc_error_break_t g_original_malloc_error_break = NULL;
 
 // Returns the function pointer for malloc_error_break. This symbol is declared
 // as __private_extern__ and cannot be dlsym()ed. Instead, use nlist() to
 // get it.
 malloc_error_break_t LookUpMallocErrorBreak() {
@@ skipping 27 matching lines @@
   reference_addr += nl[0].n_value;
 
   return reinterpret_cast<malloc_error_break_t>(reference_addr);
 #endif  // ARCH_CPU_32_BITS
 
   return NULL;
 }
 
 void CrMallocErrorBreak() {
   g_original_malloc_error_break();
-  LOG(ERROR) <<
+  DLOG(ERROR) <<
       "Terminating process due to a potential for future heap corruption";
   int* death_ptr = NULL;
   *death_ptr = 0xf00bad;
 }
 
 }  // namespace
 
 void EnableTerminationOnHeapCorruption() {
   malloc_error_break_t malloc_error_break = LookUpMallocErrorBreak();
   if (!malloc_error_break) {
-    LOG(WARNING) << "Could not find malloc_error_break";
+    DLOG(WARNING) << "Could not find malloc_error_break";
     return;
   }
 
   mach_error_t err = mach_override_ptr(
      (void*)malloc_error_break,
      (void*)&CrMallocErrorBreak,
      (void**)&g_original_malloc_error_break);
 
   if (err != err_none)
-    LOG(WARNING) << "Could not override malloc_error_break; error = " << err;
+    DLOG(WARNING) << "Could not override malloc_error_break; error = " << err;
 }
 
 // ------------------------------------------------------------------------
 
 namespace {
 
 bool g_oom_killer_enabled;
 
 // === C malloc/calloc/valloc/realloc/posix_memalign ===
 
@@ skipping 389 matching lines @@
       << "Failed to get allocWithZone allocation function.";
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 ProcessId GetParentProcessId(ProcessHandle process) {
   struct kinfo_proc info;
   size_t length = sizeof(struct kinfo_proc);
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process };
   if (sysctl(mib, 4, &info, &length, NULL, 0) < 0) {
-    PLOG(ERROR) << "sysctl";
+    DPLOG(ERROR) << "sysctl";
     return -1;
   }
   if (length == 0)
     return -1;
   return info.kp_eproc.e_ppid;
 }
 
 }  // namespace base