Remove dependency on allocator from 'content' targets

content/app/content_main_runner.cc

 // 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 "content/public/app/content_main_runner.h"
 
 #include <stdlib.h>
 
 #include <string>
 
@@ skipping 40 matching lines @@
 #include "ipc/ipc_switches.h"
 #include "media/base/media.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
 #include "gin/v8_initializer.h"
 #endif
 
-#if defined(USE_TCMALLOC)
-#include "third_party/tcmalloc/chromium/src/gperftools/malloc_extension.h"
-#endif
-
 #if !defined(OS_IOS)
 #include "content/app/mojo/mojo_init.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/utility_process_host_impl.h"
 #include "content/public/plugin/content_plugin_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/utility/content_utility_client.h"
 #endif
 
@@ skipping 29 matching lines @@
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #include "content/zygote/zygote_main.h"
 #endif
 
 #endif  // OS_POSIX
 
 #if defined(USE_NSS_CERTS)
 #include "crypto/nss_util.h"
 #endif
 
-#if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
-extern "C" {
-int tc_set_new_mode(int mode);
+#if defined(USE_TCMALLOC)
+namespace {
+
+// This method translates the tcmalloc bytes allocated function to now function
+// for alternate time source.
+unsigned int TimeSourceNowFunction() {
+  return static_cast<unsigned int>(
+      base::allocator::GetBytesAllocatedOnCurrentThread());
 }
-#endif
+
+}  // namespace
+#endif  // defined(USE_TCMALLOC)
 
 namespace content {
 extern int GpuMain(const content::MainFunctionParams&);
 #if defined(ENABLE_PLUGINS)
 #if !defined(OS_LINUX)
 extern int PluginMain(const content::MainFunctionParams&);
 #endif
 extern int PpapiPluginMain(const MainFunctionParams&);
 extern int PpapiBrokerMain(const MainFunctionParams&);
 #endif
@@ skipping 277 matching lines @@
 #if defined(OS_WIN)
     memset(&sandbox_info_, 0, sizeof(sandbox_info_));
 #endif
   }
 
   ~ContentMainRunnerImpl() override {
     if (is_initialized_ && !is_shutdown_)
       Shutdown();
   }
 
-#if defined(USE_TCMALLOC)
-  static bool GetAllocatorWasteSizeThunk(size_t* size) {
-    size_t heap_size, allocated_bytes, unmapped_bytes;
-    MallocExtension* ext = MallocExtension::instance();
-    if (ext->GetNumericProperty("generic.heap_size", &heap_size) &&
-        ext->GetNumericProperty("generic.current_allocated_bytes",
-                                &allocated_bytes) &&
-        ext->GetNumericProperty("tcmalloc.pageheap_unmapped_bytes",
-                                &unmapped_bytes)) {
-      *size = heap_size - allocated_bytes - unmapped_bytes;
-      return true;
-    }
-    DCHECK(false);
-    return false;
-  }
-
-  static void GetStatsThunk(char* buffer, int buffer_length) {
-    MallocExtension::instance()->GetStats(buffer, buffer_length);
-  }
-
-  static bool GetNumericPropertyThunk(const char* name, size_t* value) {
-    return MallocExtension::instance()->GetNumericProperty(name, value);
-  }
-
-  static void ReleaseFreeMemoryThunk() {
-    MallocExtension::instance()->ReleaseFreeMemory();
-  }
-#endif
-
   int Initialize(const ContentMainParams& params) override {
     ui_task_ = params.ui_task;
 
     base::EnableTerminationOnOutOfMemory();
 #if defined(OS_WIN)
     base::win::RegisterInvalidParamHandler();
     ui::win::CreateATLModuleIfNeeded();
 
     sandbox_info_ = *params.sandbox_info;
 #else  // !OS_WIN
 
 #if defined(OS_ANDROID)
     // See note at the initialization of ExitManager, below; basically,
     // only Android builds have the ctor/dtor handlers set up to use
     // TRACE_EVENT right away.
     TRACE_EVENT0("startup,benchmark", "ContentMainRunnerImpl::Initialize");
 #endif  // OS_ANDROID
 
-    // NOTE(willchan): One might ask why these TCMalloc-related calls are done
-    // here rather than in process_util_linux.cc with the definition of
-    // EnableTerminationOnOutOfMemory().  That's because base shouldn't have a
-    // dependency on TCMalloc.  Really, we ought to have our allocator shim code
-    // implement this EnableTerminationOnOutOfMemory() function.  Whateverz.
-    // This works for now.
 #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
-    // For tcmalloc, we need to tell it to behave like new.
-    tc_set_new_mode(1);
-
-    // On windows, we've already set these thunks up in _heap_init()
-    base::allocator::SetGetAllocatorWasteSizeFunction(
-        GetAllocatorWasteSizeThunk);
-    base::allocator::SetGetStatsFunction(GetStatsThunk);
-    base::allocator::SetGetNumericPropertyFunction(GetNumericPropertyThunk);
-    base::allocator::SetReleaseFreeMemoryFunction(ReleaseFreeMemoryThunk);
+    // Allocator initialization is needed for tcmalloc to set up the allocator
+    // extension callbacks. This needs to happen before any threads are created
+    // and any of the extension methods is used. To be able to call this method
+    // implies that the executable target should link in the allocator shim
+    // implementation. Note that the content target does not decide the
+    // allocator.
+    base::allocator::InitializeAllocator();
 
     // Provide optional hook for monitoring allocation quantities on a
     // per-thread basis.  Only set the hook if the environment indicates this
     // needs to be enabled.
     const char* profiling = getenv(tracked_objects::kAlternateProfilerTime);
     if (profiling &&
         (atoi(profiling) == tracked_objects::TIME_SOURCE_TYPE_TCMALLOC)) {
       tracked_objects::SetAlternateTimeSource(
-          MallocExtension::GetBytesAllocatedOnCurrentThread,
-          tracked_objects::TIME_SOURCE_TYPE_TCMALLOC);
+          TimeSourceNowFunction, tracked_objects::TIME_SOURCE_TYPE_TCMALLOC);
     }
 #endif  // !OS_MACOSX && USE_TCMALLOC
 
 #if !defined(OS_IOS)
     base::GlobalDescriptors* g_fds = base::GlobalDescriptors::GetInstance();
 #endif
 
     // On Android,
     // - setlocale() is not supported.
     // - We do not override the signal handlers so that we can get
@@ skipping 364 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContentMainRunnerImpl);
 };
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content