Avoid spawning a thread while enabling the OOM killer on the Mac....

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/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
@@ skipping 576 matching lines @@
     return malloc_purgeable_zone();
   return NULL;
 }
 
 void EnableTerminationOnOutOfMemory() {
   if (g_oom_killer_enabled)
     return;
 
   g_oom_killer_enabled = true;
 
-  int32 os_major;
-  int32 os_minor;
-  int32 os_bugfix;
-  SysInfo::OperatingSystemVersionNumbers(&os_major, &os_minor, &os_bugfix);
+  // 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, (char**)NULL, 10);

[Mark Mentovai, 2010/08/24 15:13:24]

Do you really need this cast?

[Avi (use Gerrit), 2010/08/24 15:16:37]

No. Done.

 
   // === 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/WebKitTools/DumpRenderTree/mac
-  bool zone_allocators_protected =
-      ((os_major == 10 && os_minor > 6) || os_major > 10);
+  bool zone_allocators_protected = darwin_version > 10;
 
   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 95 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 =
-      (os_major == 10 && (os_minor == 5 || os_minor == 6));
+      (darwin_version == 9) || (darwin_version == 10);

[Mark Mentovai, 2010/08/24 15:13:24]

The parentheses aren’t necessary and I don’t think they make anything clearer.

The old code had |os_minor == 5 || os_minor == 6|, seems the same as just
writing |darwin_version == 9 || darwin_version == 10|.

[Avi (use Gerrit), 2010/08/24 15:16:37]

Done.

 
   if (cf_allocator_internals_known) {
     ChromeCFAllocatorRef allocator = const_cast<ChromeCFAllocatorRef>(
         reinterpret_cast<const ChromeCFAllocator*>(kCFAllocatorSystemDefault));
     g_old_cfallocator_system_default = allocator->context.allocate;
     CHECK(g_old_cfallocator_system_default)
         << "Failed to get kCFAllocatorSystemDefault allocation function.";
     allocator->context.allocate = oom_killer_cfallocator_system_default;
 
     allocator = const_cast<ChromeCFAllocatorRef>(
@@ skipping 27 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