Deinline PartitionAlloc from DefaultAllocator to reduce code size

Source/wtf/DefaultAllocator.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 55 matching lines @@
     struct VectorBackingHelper {
         typedef void Type;
     };
     template<typename T>
     struct HashTableBackingHelper {
         typedef void Type;
     };
     template <typename Return, typename Metadata>
     static Return backingMalloc(size_t size)
     {
-        return reinterpret_cast<Return>(partitionAllocGeneric(Partitions::getBufferPartition(), size));
+        return reinterpret_cast<Return>(backingAllocate(size));
     }
     template <typename Return, typename Metadata>
     static Return zeroedBackingMalloc(size_t size)
     {
-        void* result = partitionAllocGeneric(Partitions::getBufferPartition(), size);
+        void* result = backingAllocate(size);
         memset(result, 0, size);
         return reinterpret_cast<Return>(result);
     }
     template <typename Return, typename Metadata>
     static Return malloc(size_t size)
     {
         return reinterpret_cast<Return>(fastMalloc(size));
     }
-    static void backingFree(void* address)
-    {
-        partitionFreeGeneric(Partitions::getBufferPartition(), address);
-    }
+    WTF_EXPORT static void backingFree(void* address);
     static void free(void* address)
     {
         fastFree(address);
     }
     template<typename T>
     static void* newArray(size_t bytes)
     {
         return malloc<void*, void>(bytes);
     }
     static void
@@ skipping 21 matching lines @@
     template<typename T>
     struct OtherType {
         typedef T* Type;
     };
 
     template<typename T>
     static T& getOther(T* other)
     {
         return *other;
     }
+
+private:
+    WTF_EXPORT static void* backingAllocate(size_t);
 };
 
 // The Windows compiler seems to be very eager to instantiate things it won't
 // need, so unless we have this class we get compile errors.
 class DefaultAllocatorDummyVisitor {
 public:
     template<typename T> inline bool isAlive(T obj)
     {
         ASSERT_NOT_REACHED();
         return false;
@@ skipping 15 matching lines @@
     { \
         ASSERT(location); \
         return location; \
     } \
 private: \
 typedef int __thisIsHereToForceASemicolonAfterThisMacro
 
 using WTF::DefaultAllocator;
 
 #endif // WTF_DefaultAllocator_h