Rename IsAllowOnlyInlineAllocation<T> to AllowsOnlyPlacementNew<T>.

third_party/WebKit/Source/wtf/Allocator.h

 // Copyright 2015 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 WTF_Allocator_h
 #define WTF_Allocator_h
 
 #include "wtf/Assertions.h"
 #include "wtf/Partitions.h"
 #include "wtf/StdLibExtras.h"
@@ skipping 15 matching lines @@
 // DISALLOW_NEW(): Cannot be allocated with new operators but can be a
 // part of object.  If it has Members you need a trace method and the containing
 // object needs to call that trace method.
 //
 // DISALLOW_NEW_EXCEPT_PLACEMENT_NEW(): Allows only placement new operator.  This
 // disallows general allocation of this object but allows to put the object as a
 // value object in collections.  If these have Members you need to have a trace
 // method. That trace method will be called automatically by the on-heap
 // collections.
 //
-#define DISALLOW_NEW()                                   \
+#define DISALLOW_NEW()                                          \
     private:                                                    \
         void* operator new(size_t) = delete;                    \
         void* operator new(size_t, NotNullTag, void*) = delete; \
         void* operator new(size_t, void*) = delete;             \
     public:
 
-#define DISALLOW_NEW_EXCEPT_PLACEMENT_NEW()                                              \
+#define DISALLOW_NEW_EXCEPT_PLACEMENT_NEW()                                         \
     public:                                                                         \
-        using IsAllowOnlyInlineAllocation = int;                                    \
+        using IsAllowOnlyPlacementNew = int;                                        \
         void* operator new(size_t, NotNullTag, void* location) { return location; } \
         void* operator new(size_t, void* location) { return location; }             \
     private:                                                                        \
         void* operator new(size_t) = delete;                                        \
     public:
 
 #define STATIC_ONLY(Type) \
     private:              \
         Type() = delete;  \
         Type(const Type&) = delete;                             \
@@ skipping 70 matching lines @@
     static const char* classNameForAllocator() \
     { \
         return #type; \
     } \
 private: \
 typedef int __thisIsHereToForceASemicolonAfterThisMacro
 
 } // namespace WTF
 
 #endif /* WTF_Allocator_h */