Merge the LINUX_TC_MALLOC #define with the existing TC_MALLOC #define....

base/process_util_linux.cc

 // Copyright (c) 2009 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"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
@@ skipping 495 matching lines @@
   CHECK(false) << "Out of memory.";
 }
 
 void OnNoMemory() {
   OnNoMemorySize(0);
 }
 
 }  // namespace
 
 extern "C" {
-
-#if !defined(LINUX_USE_TCMALLOC)
+#if !defined(USE_TCMALLOC)
 
 extern "C" {
 void* __libc_malloc(size_t size);
 void* __libc_realloc(void* ptr, size_t size);
 void* __libc_calloc(size_t nmemb, size_t size);
 void* __libc_valloc(size_t size);
 void* __libc_pvalloc(size_t size);
 void* __libc_memalign(size_t alignment, size_t size);
 }  // extern "C"
 
 // Overriding the system memory allocation functions:
 //
 // For security reasons, we want malloc failures to be fatal. Too much code
 // doesn't check for a NULL return value from malloc and unconditionally uses
 // the resulting pointer. If the first offset that they try to access is
 // attacker controlled, then the attacker can direct the code to access any
 // part of memory.
 //
 // Thus, we define all the standard malloc functions here and mark them as
 // visibility 'default'. This means that they replace the malloc functions for
 // all Chromium code and also for all code in shared libraries. There are tests
 // for this in process_util_unittest.cc.
 //
 // If we are using tcmalloc, then the problem is moot since tcmalloc handles
-// this for us. Thus this code is in a !defined(LINUX_USE_TCMALLOC) block.
+// this for us. Thus this code is in a !defined(USE_TCMALLOC) block.
 //
 // We call the real libc functions in this code by using __libc_malloc etc.
 // Previously we tried using dlsym(RTLD_NEXT, ...) but that failed depending on
 // the link order. Since ld.so needs calloc during symbol resolution, it
 // defines its own versions of several of these functions in dl-minimal.c.
 // Depending on the runtime library order, dlsym ended up giving us those
 // functions and bad things happened. See crbug.com/31809
 //
 // This means that any code which calls __libc_* gets the raw libc versions of
 // these functions.
@@ skipping 30 matching lines @@
 // posix_memalign has a unique signature and doesn't have a __libc_ variant.
 int posix_memalign(void** ptr, size_t alignment, size_t size)
     __attribute__ ((visibility("default")));
 
 int posix_memalign(void** ptr, size_t alignment, size_t size) {
   // This will use the safe version of memalign, above.
   *ptr = memalign(alignment, size);
   return 0;
 }
 
-#endif  // !defined(LINUX_USE_TCMALLOC)
+#endif  // !defined(USE_TCMALLOC)
 }  // extern C
 
 void EnableTerminationOnOutOfMemory() {
   // Set the new-out of memory handler.
   std::set_new_handler(&OnNoMemory);
   // If we're using glibc's allocator, the above functions will override
   // malloc and friends and make them die on out of memory.
 }
 
 bool AdjustOOMScore(ProcessId process, int score) {
   if (score < 0 || score > 15)
     return false;
 
   FilePath oom_adj("/proc");
   oom_adj = oom_adj.Append(Int64ToString(process));
   oom_adj = oom_adj.AppendASCII("oom_adj");
 
   if (!file_util::PathExists(oom_adj))
     return false;
 
   std::string score_str = IntToString(score);
   return (static_cast<int>(score_str.length()) ==
           file_util::WriteFile(oom_adj, score_str.c_str(), score_str.length()));
 }
 
 }  // namespace base