Remove log message for 10.8 CFAllocator patching.

base/process_util_mac.mm

 // Copyright (c) 2012 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 <errno.h>
@@ skipping 752 matching lines @@
 
 // === C++ operator new ===
 
 void oom_killer_new() {
   debug::BreakDebugger();
 }
 
 // === Core Foundation CFAllocators ===
 
 bool CanGetContextForCFAllocator() {
-  // TODO(avi): remove at final release; http://crbug.com/117476
-  if (base::mac::IsOSMountainLion()) {
-    NSLog(@"Unsure about the internals of CFAllocator but going to patch them "
-           "anyway. If there is a crash inside of CFAllocatorAllocate, please "
-           "report it at http://crbug.com/117476 . If there is a crash and it "
-           "is NOT inside of CFAllocatorAllocate, it is NOT RELATED. DO NOT "
-           "REPORT IT THERE but rather FILE A NEW BUG.");
-  }
   return !base::mac::
       IsOSDangerouslyLaterThanMountainLionForUseByCFAllocatorReplacement();

[Mark Mentovai, 2012/08/07 16:43:03]

We’re gonna need to remember to do something with this each time there’s a new
major OS version. How do you plan to track that?

[Avi (use Gerrit), 2012/08/07 16:54:54]

I plan on doing all of the same work; digging up the new structure, updating
base::mac, etc, etc. I just don't want to log "hey we're patching it anyway"
since that accomplishes nothing.

Note the length of this comment as opposed to the one from 10.7. This is thrice
the length trying to explain to people when to file bugs and where. It's clear
that doesn't work.

 }
 
 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 (base::mac::IsOSLion() || base::mac::IsOSMountainLion()) {
     ChromeCFAllocatorLions* our_allocator =
@@ skipping 231 matching lines @@
         << "Failed to get kCFAllocatorMalloc allocation function.";
     context->allocate = oom_killer_cfallocator_malloc;
 
     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 "

[Mark Mentovai, 2012/08/07 17:01:08]

OK, so when 10.next starts running, people will see THIS message spamming the
console. Are we still OK with that too, or do we want to try to make this
browser-only?

[Avi (use Gerrit), 2012/08/07 17:10:08]

a. Yes, I'm OK with this message. The amount of time between a new system
release and our update to the CFAllocator code is going to be significantly less
than the time during which we are running unverified CFAllocator patch code.
Plus, the people who are running Chrome during that time are more experienced
devs, as opposed to the wide range of people who run the beta and the release.

b. If you look at content_main_runner's Initialize(), the call to
EnableTerminationOnOutOfMemory() precedes command-line parsing. You need to
parse the command line to determine if you are the browser process, but enabling
the OOM killer is something that I'd really like to keep early in the app
startup code. Could someone do an OOM attack via the command-line?

         "CFAllocator will not result in termination. http://crbug.com/45650");
   }
 #endif
 
   // === Cocoa NSObject allocation ===
 
   // Note that both +[NSObject new] and +[NSObject alloc] call through to
   // +[NSObject allocWithZone:].
 
   CHECK(!g_old_allocWithZone)
@@ skipping 172 matching lines @@
   }
 }
 
 }  // namespace
 
 void EnsureProcessTerminated(ProcessHandle process) {
   WaitForChildToDie(process, kWaitBeforeKillSeconds);
 }
 
 }  // namespace base