Adding allocator annotations to blink classes and structs.

Source/bindings/core/v8/ScriptValueSerializer.h

 // Copyright 2014 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 ScriptValueSerializer_h
 #define ScriptValueSerializer_h
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 18 matching lines @@
 
 // V8ObjectMap is a map from V8 objects to arbitrary values of type T.
 // V8 objects (or handles to V8 objects) cannot be used as keys in ordinary wtf::HashMaps;
 // this class should be used instead. GCObject must be a subtype of v8::Object.
 // Suggested usage:
 //     V8ObjectMap<v8::Object, int> map;
 //     v8::Local<v8::Object> obj = ...;
 //     map.set(obj, 42);
 template<typename GCObject, typename T>
 class V8ObjectMap {
+    STACK_ALLOCATED();
 public:
     bool contains(const v8::Local<GCObject>& handle)
     {
         return m_map.contains(*handle);
     }
 
     bool tryGet(const v8::Local<GCObject>& handle, T* valueOut)
     {
         typename HandleToT::iterator result = m_map.find(*handle);
         if (result != m_map.end()) {
@@ skipping 30 matching lines @@
         static unsigned hash(const G* key)
         {
             return static_cast<unsigned>(unsafeHandleFromRawValue(key)->GetIdentityHash());
         }
         static bool equal(const G* a, const G* b)
         {
             return unsafeHandleFromRawValue(a) == unsafeHandleFromRawValue(b);
         }
         // For HashArg.
         static const bool safeToCompareToEmptyOrDeleted = false;
+        STATIC_ONLY(V8HandlePtrHash);
     };
 
     typedef WTF::HashMap<GCObject*, T, V8HandlePtrHash<GCObject>> HandleToT;
     HandleToT m_map;
 };
 
 // SerializedScriptValueWriter is responsible for serializing primitive types and storing
 // information used to reconstruct composite types.
 class CORE_EXPORT SerializedScriptValueWriter {
     STACK_ALLOCATED();
@@ skipping 103 matching lines @@
 
     ScriptValueSerializer(SerializedScriptValueWriter&, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, WebBlobInfoArray*, BlobDataHandleMap& blobDataHandles, v8::TryCatch&, ScriptState*);
     v8::Isolate* isolate() { return m_scriptState->isolate(); }
     v8::Local<v8::Context> context() { return m_scriptState->context(); }
 
     Status serialize(v8::Local<v8::Value>);
     String errorMessage() { return m_errorMessage; }
 
 protected:
     class StateBase {
+        WTF_MAKE_FAST_ALLOCATED(StateBase);
         WTF_MAKE_NONCOPYABLE(StateBase);
     public:
         virtual ~StateBase() { }
 
         // Link to the next state to form a stack.
         StateBase* nextState() { return m_next; }
 
         // Composite object we're processing in this state.
         v8::Local<v8::Value> composite() { return m_composite; }
 
@@ skipping 399 matching lines @@
     Vector<uint32_t> m_openCompositeReferenceStack;
     MessagePortArray* m_transferredMessagePorts;
     ArrayBufferContentsArray* m_arrayBufferContents;
     Vector<v8::Local<v8::Value>> m_arrayBuffers;
     uint32_t m_version;
 };
 
 } // namespace blink
 
 #endif // ScriptValueSerializer_h