Move debug-related stuff from base to the base/debug directory and use the...

base/process_util_mac.mm

 // Copyright (c) 2008 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>
 #include <mach/mach_init.h>
 #include <mach/task.h>
 #include <malloc/malloc.h>
 #import <objc/runtime.h>
 #include <spawn.h>
 #include <sys/mman.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <sys/wait.h>
 
 #include <new>
 #include <string>
 
-#include "base/debug_util.h"
+#include "base/debug/debugger.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "base/time.h"
 #include "third_party/apple_apsl/CFBase.h"
 #include "third_party/apple_apsl/malloc.h"
 
 namespace base {
@@ skipping 122 matching lines @@
                               exec_name_end - last_slash - 1);
     // Start w/ the next entry next time through
     ++index_of_kinfo_proc_;
     // Done
     return true;
   }
   return false;
 }
 
 bool NamedProcessIterator::IncludeEntry() {
-  return (base::SysWideToUTF8(executable_name_) == entry().exe_file() &&
+  return (SysWideToUTF8(executable_name_) == entry().exe_file() &&
           ProcessIterator::IncludeEntry());
 }
 
 
 // ------------------------------------------------------------------------
 // NOTE: about ProcessMetrics
 //
 // Getting a mach task from a pid for another process requires permissions in
 // general, so there doesn't really seem to be a way to do these (and spinning
 // up ps to fetch each stats seems dangerous to put in a base api for anyone to
 // call). Child processes ipc their port, so return something if available,
 // otherwise return 0.
 //
 
 ProcessMetrics::ProcessMetrics(ProcessHandle process,
                                ProcessMetrics::PortProvider* port_provider)
     : process_(process),
       last_time_(0),
       last_system_time_(0),
       port_provider_(port_provider) {
-  processor_count_ = base::SysInfo::NumberOfProcessors();
+  processor_count_ = SysInfo::NumberOfProcessors();
 }
 
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(
     ProcessHandle process,
     ProcessMetrics::PortProvider* port_provider) {
   return new ProcessMetrics(process, port_provider);
 }
 
 bool ProcessMetrics::GetIOCounters(IoCounters* io_counters) const {
@@ skipping 194 matching lines @@
 malloc_type g_old_malloc_purgeable;
 calloc_type g_old_calloc_purgeable;
 valloc_type g_old_valloc_purgeable;
 realloc_type g_old_realloc_purgeable;
 memalign_type g_old_memalign_purgeable;
 
 void* oom_killer_malloc(struct _malloc_zone_t* zone,
                         size_t size) {
   void* result = g_old_malloc(zone, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_calloc(struct _malloc_zone_t* zone,
                         size_t num_items,
                         size_t size) {
   void* result = g_old_calloc(zone, num_items, size);
   if (!result && num_items && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_valloc(struct _malloc_zone_t* zone,
                         size_t size) {
   void* result = g_old_valloc(zone, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_realloc(struct _malloc_zone_t* zone,
                          void* ptr,
                          size_t size) {
   void* result = g_old_realloc(zone, ptr, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_memalign(struct _malloc_zone_t* zone,
                           size_t alignment,
                           size_t size) {
   void* result = g_old_memalign(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*)
       && (alignment & (alignment - 1)) == 0) {
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   }
   return result;
 }
 
 void* oom_killer_malloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
   void* result = g_old_malloc_purgeable(zone, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_calloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t num_items,
                                   size_t size) {
   void* result = g_old_calloc_purgeable(zone, num_items, size);
   if (!result && num_items && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_valloc_purgeable(struct _malloc_zone_t* zone,
                                   size_t size) {
   void* result = g_old_valloc_purgeable(zone, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_realloc_purgeable(struct _malloc_zone_t* zone,
                                    void* ptr,
                                    size_t size) {
   void* result = g_old_realloc_purgeable(zone, ptr, size);
   if (!result && size)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_memalign_purgeable(struct _malloc_zone_t* zone,
                                     size_t alignment,
                                     size_t size) {
   void* result = g_old_memalign_purgeable(zone, alignment, size);
   // Only die if posix_memalign would have returned ENOMEM, since there are
   // other reasons why NULL might be returned (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c ).
   if (!result && size && alignment >= sizeof(void*)
       && (alignment & (alignment - 1)) == 0) {
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   }
   return result;
 }
 
 // === C++ operator new ===
 
 void oom_killer_new() {
-  DebugUtil::BreakDebugger();
+  debugger::BreakDebugger();
 }
 
 // === Core Foundation CFAllocators ===
 
 typedef ChromeCFAllocator* ChromeCFAllocatorRef;
 
 CFAllocatorAllocateCallBack g_old_cfallocator_system_default;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc_zone;
 
 void* oom_killer_cfallocator_system_default(CFIndex alloc_size,
                                             CFOptionFlags hint,
                                             void* info) {
   void* result = g_old_cfallocator_system_default(alloc_size, hint, info);
   if (!result)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_cfallocator_malloc(CFIndex alloc_size,
                                     CFOptionFlags hint,
                                     void* info) {
   void* result = g_old_cfallocator_malloc(alloc_size, hint, info);
   if (!result)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 void* oom_killer_cfallocator_malloc_zone(CFIndex alloc_size,
                                          CFOptionFlags hint,
                                          void* info) {
   void* result = g_old_cfallocator_malloc_zone(alloc_size, hint, info);
   if (!result)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 // === Cocoa NSObject allocation ===
 
 typedef id (*allocWithZone_t)(id, SEL, NSZone*);
 allocWithZone_t g_old_allocWithZone;
 
 id oom_killer_allocWithZone(id self, SEL _cmd, NSZone* zone)
 {
   id result = g_old_allocWithZone(self, _cmd, zone);
   if (!result)
-    DebugUtil::BreakDebugger();
+    debugger::BreakDebugger();
   return result;
 }
 
 }  // namespace
 
 malloc_zone_t* GetPurgeableZone() {
   // malloc_default_purgeable_zone only exists on >= 10.6. Use dlsym to grab it
   // at runtime because it may not be present in the SDK used for compilation.
   typedef malloc_zone_t* (*malloc_default_purgeable_zone_t)(void);
   malloc_default_purgeable_zone_t malloc_purgeable_zone =
@@ skipping 196 matching lines @@
                                             @selector(allocWithZone:));
   g_old_allocWithZone = reinterpret_cast<allocWithZone_t>(
       method_getImplementation(orig_method));
   CHECK(g_old_allocWithZone)
       << "Failed to get allocWithZone allocation function.";
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 }  // namespace base