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 14 matching lines @@
     // never needs to be rebuilt across garbage collections at the expense of doing additional allocation
     // and making more round trips into V8. Note that since GetIdentityHash() is defined only on
     // v8::Objects, this V8ObjectMap cannot be used to map v8::Strings to T (because the public V8 API
     // considers a v8::String to be a v8::Primitive).
 
     // If V8 exposes a way to get at the address of the object held by a handle, then we can produce
     // an alternate implementation that does not need to do any V8-side allocation; however, it will
     // need to rehash after every garbage collection because a key object may have been moved.
     template<typename G>
     struct V8HandlePtrHash {
+        STATIC_ONLY(V8HandlePtrHash);
         static v8::Local<G> unsafeHandleFromRawValue(const G* value)
         {
             const v8::Local<G>* handle = reinterpret_cast<const v8::Local<G>*>(&value);
             return *handle;
         }
 
         static unsigned hash(const G* key)
         {
             return static_cast<unsigned>(unsafeHandleFromRawValue(key)->GetIdentityHash());
         }
@@ skipping 119 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