Improve and unify Mac OS X run-time version checks

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>
 #include <mach/mach_init.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.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/debugger.h"
 #include "base/eintr_wrapper.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
+#include "base/mac/mac_util.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 {
 
 void RestoreDefaultExceptionHandler() {
@@ skipping 573 matching lines @@
 }
 
 // === C++ operator new ===
 
 void oom_killer_new() {
   debug::BreakDebugger();
 }
 
 // === Core Foundation CFAllocators ===
 
-bool CanGetContextForCFAllocator(long darwin_version) {
+bool CanGetContextForCFAllocator() {
   // TODO(avi): remove at final release; http://crbug.com/74589
-  if (darwin_version == 11) {
+  if (base::mac::IsOSLion()) {
     NSLog(@"Unsure about the internals of CFAllocator but going to patch them "
            "anyway. Watch out for crashes inside of CFAllocatorAllocate.");
   }
-  return darwin_version == 9 ||
-         darwin_version == 10 ||
-         darwin_version == 11;
+  return !base::mac::IsOSLaterThanLion();
 }
 
-CFAllocatorContext* ContextForCFAllocator(CFAllocatorRef allocator,
-                                          long darwin_version) {
-  if (darwin_version == 9 || darwin_version == 10) {
-    ChromeCFAllocator9and10* our_allocator =
-        const_cast<ChromeCFAllocator9and10*>(
-            reinterpret_cast<const ChromeCFAllocator9and10*>(allocator));
+CFAllocatorContext* ContextForCFAllocator(CFAllocatorRef allocator) {
+  if (base::mac::IsOSLeopard() || base::mac::IsOSSnowLeopard()) {
+    ChromeCFAllocatorLeopards* our_allocator =
+        const_cast<ChromeCFAllocatorLeopards*>(
+            reinterpret_cast<const ChromeCFAllocatorLeopards*>(allocator));
     return &our_allocator->_context;
-  } else if (darwin_version == 11) {
-    ChromeCFAllocator11* our_allocator =
-        const_cast<ChromeCFAllocator11*>(
-            reinterpret_cast<const ChromeCFAllocator11*>(allocator));
+  } else if (base::mac::IsOSLion()) {
+    ChromeCFAllocatorLion* our_allocator =
+        const_cast<ChromeCFAllocatorLion*>(
+            reinterpret_cast<const ChromeCFAllocatorLion*>(allocator));
     return &our_allocator->_context;
   } else {
     return NULL;
   }
 }
 
 CFAllocatorAllocateCallBack g_old_cfallocator_system_default;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc;
 CFAllocatorAllocateCallBack g_old_cfallocator_malloc_zone;
 
@@ skipping 50 matching lines @@
     return malloc_purgeable_zone();
   return NULL;
 }
 
 void EnableTerminationOnOutOfMemory() {
   if (g_oom_killer_enabled)
     return;
 
   g_oom_killer_enabled = true;
 
-  // Not SysInfo::OperatingSystemVersionNumbers as that calls through to Gestalt
-  // which ends up (on > 10.6) spawning threads.
-  struct utsname machine_info;
-  if (uname(&machine_info)) {
-    return;
-  }
-
-  // The string machine_info.release is the xnu/Darwin version number, "9.xxx"
-  // on Mac OS X 10.5, and "10.xxx" on Mac OS X 10.6. See
-  // http://en.wikipedia.org/wiki/Darwin_(operating_system) .
-  long darwin_version = strtol(machine_info.release, NULL, 10);
-
   // === C malloc/calloc/valloc/realloc/posix_memalign ===
 
   // This approach is not perfect, as requests for amounts of memory larger than
   // MALLOC_ABSOLUTE_MAX_SIZE (currently SIZE_T_MAX - (2 * PAGE_SIZE)) will
   // still fail with a NULL rather than dying (see
   // http://opensource.apple.com/source/Libc/Libc-583/gen/malloc.c for details).
   // Unfortunately, it's the best we can do. Also note that this does not affect
   // allocations from non-default zones.
 
   CHECK(!g_old_malloc && !g_old_calloc && !g_old_valloc && !g_old_realloc &&
         !g_old_memalign) << "Old allocators unexpectedly non-null";
 
   CHECK(!g_old_malloc_purgeable && !g_old_calloc_purgeable &&
         !g_old_valloc_purgeable && !g_old_realloc_purgeable &&
         !g_old_memalign_purgeable) << "Old allocators unexpectedly non-null";
 
   // See http://trac.webkit.org/changeset/53362/trunk/Tools/DumpRenderTree/mac
-  bool zone_allocators_protected = darwin_version > 10;
+  bool zone_allocators_protected = base::mac::IsOSLionOrLater();
 
   ChromeMallocZone* default_zone =
       reinterpret_cast<ChromeMallocZone*>(malloc_default_zone());
   ChromeMallocZone* purgeable_zone =
       reinterpret_cast<ChromeMallocZone*>(GetPurgeableZone());
 
   vm_address_t page_start_default = NULL;
   vm_address_t page_start_purgeable = NULL;
   vm_size_t len_default = 0;
   vm_size_t len_purgeable = 0;
@@ skipping 94 matching lines @@
 
   // === Core Foundation CFAllocators ===
 
   // This will not catch allocation done by custom allocators, but will catch
   // all allocation done by system-provided ones.
 
   CHECK(!g_old_cfallocator_system_default && !g_old_cfallocator_malloc &&
         !g_old_cfallocator_malloc_zone)
       << "Old allocators unexpectedly non-null";
 
-  bool cf_allocator_internals_known =
-      CanGetContextForCFAllocator(darwin_version);
+  bool cf_allocator_internals_known = CanGetContextForCFAllocator();
 
   if (cf_allocator_internals_known) {
     CFAllocatorContext* context =
-        ContextForCFAllocator(kCFAllocatorSystemDefault, darwin_version);
+        ContextForCFAllocator(kCFAllocatorSystemDefault);
     CHECK(context) << "Failed to get context for kCFAllocatorSystemDefault.";
     g_old_cfallocator_system_default = context->allocate;
     CHECK(g_old_cfallocator_system_default)
         << "Failed to get kCFAllocatorSystemDefault allocation function.";
     context->allocate = oom_killer_cfallocator_system_default;
 
-    context = ContextForCFAllocator(kCFAllocatorMalloc, darwin_version);
+    context = ContextForCFAllocator(kCFAllocatorMalloc);
     CHECK(context) << "Failed to get context for kCFAllocatorMalloc.";
     g_old_cfallocator_malloc = context->allocate;
     CHECK(g_old_cfallocator_malloc)
         << "Failed to get kCFAllocatorMalloc allocation function.";
     context->allocate = oom_killer_cfallocator_malloc;
 
-    context = ContextForCFAllocator(kCFAllocatorMallocZone, darwin_version);
+    context = ContextForCFAllocator(kCFAllocatorMallocZone);
     CHECK(context) << "Failed to get context for kCFAllocatorMallocZone.";
     g_old_cfallocator_malloc_zone = context->allocate;
     CHECK(g_old_cfallocator_malloc_zone)
         << "Failed to get kCFAllocatorMallocZone allocation function.";
     context->allocate = oom_killer_cfallocator_malloc_zone;
   } else {
     NSLog(@"Internals of CFAllocator not known; out-of-memory failures via "
         "CFAllocator will not result in termination. http://crbug.com/45650");
   }
 
@@ skipping 23 matching lines @@
   if (sysctl(mib, 4, &info, &length, NULL, 0) < 0) {
     PLOG(ERROR) << "sysctl";
     return -1;
   }
   if (length == 0)
     return -1;
   return info.kp_eproc.e_ppid;
 }
 
 }  // namespace base