Remove dependency on allocator from 'content' targets

base/allocator/allocator_extension.h

 // 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.
 
 #ifndef BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_
 #define BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_
 
 #include <stddef.h> // for size_t
 
 #include "base/allocator/allocator_extension_thunks.h"
 #include "base/base_export.h"
 #include "build/build_config.h"
 
 namespace base {
 namespace allocator {
 
+// Initializes the allocator and the routes the extension functions

[Primiano Tucci (use gerrit), 2015/11/25 12:47:17]

"the routes the extension functions implementations to base?"

+// implementations to base. This should be called only once and called before
+// the other allocator extension functions. This function is NOT thread safe and
+// the caller should ensure that it is called before any thread attempts to call
+// the below functions.
+// Do not call this function unless there is an allocator library that replaces
+// the underlying weak function, which is expected to provide the necessary
+// callbacks for the functions below. See InitializeAllocatorWeak.
+BASE_EXPORT void InitializeAllocator();
+
 // Request the allocator to report value of its waste memory size.
 // Waste size corresponds to memory that has been allocated from the OS but
 // not passed up to the application. It e.g. includes memory retained by free
 // lists, internal data, chunks padding, etc.
 //
 // |size| pointer to the returned value, must be not NULL.
 // Returns true if the value has been returned, false otherwise.
 BASE_EXPORT bool GetAllocatorWasteSize(size_t* size);
 
 // Request that the allocator print a human-readable description of the current
 // state of the allocator into a null-terminated string in the memory segment
 // buffer[0,buffer_length-1].
 //
 // |buffer| must point to a valid piece of memory
 // |buffer_length| must be > 0.
 BASE_EXPORT void GetStats(char* buffer, int buffer_length);
 
 // Request that the allocator release any free memory it knows about to the
 // system.
 BASE_EXPORT void ReleaseFreeMemory();
 
+// Returns the total bytes allocated in the current thread.
+BASE_EXPORT size_t GetBytesAllocatedOnCurrentThread();
 
-// These settings allow specifying a callback used to implement the allocator
-// extension functions.  These are optional, but if set they must only be set
-// once.  These will typically called in an allocator-specific initialization
-// routine.
-//
-// No threading promises are made.  The caller is responsible for making sure
-// these pointers are set before any other threads attempt to call the above
-// functions.
-BASE_EXPORT void SetGetAllocatorWasteSizeFunction(
-    thunks::GetAllocatorWasteSizeFunction get_allocator_waste_size_function);
+// Get the named property's |value|. Returns true if the property is known.
+// Returns false if the property is not a valid property name for the current
+// malloc implementation.
+// |name| or |value| cannot be NULL
+BASE_EXPORT bool GetNumericProperty(const char* name, size_t* value);
 
-BASE_EXPORT void SetGetStatsFunction(
-    thunks::GetStatsFunction get_stats_function);
+// The following are used for heap profiling if the allocator implementation
+// supports.
 
-BASE_EXPORT void SetReleaseFreeMemoryFunction(
-    thunks::ReleaseFreeMemoryFunction release_free_memory_function);
+// Start and stop heap profiler:
+typedef thunks::AllocatorExtensionFunctions::StackGenerator
+    StackGeneratorFunction;
+BASE_EXPORT void HeapProfilerStart(StackGeneratorFunction callback);
+BASE_EXPORT void HeapProfilerStop();
 
-BASE_EXPORT void SetGetNumericPropertyFunction(
-    thunks::GetNumericPropertyFunction get_numeric_property_function);
+// Generate current heap profiling information and return as string.
+BASE_EXPORT char* GetHeapProfile();
+
+// Generate current heap profiling information and write to file.
+BASE_EXPORT void HeapProfilerDump(const char* reason);
+
+// Return true if heap profiler is running.
+BASE_EXPORT bool IsHeapProfilerRunning();
 
 }  // namespace allocator
 }  // namespace base
 
 #endif  // BASE_ALLOCATOR_ALLOCATOR_EXTENSION_H_