Update more bindings classes to use OVERRIDE / FINAL when needed

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 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 787 matching lines @@
             , m_next(next)
         {
         }
 
     private:
         v8::Handle<v8::Value> m_composite;
         StateBase* m_next;
     };
 
     // Dummy state that is used to signal serialization errors.
-    class ErrorState : public StateBase {
+    class ErrorState FINAL : public StateBase {
     public:
         ErrorState()
             : StateBase(v8Undefined(), 0)
         {
         }
 
-        virtual StateBase* advance(Serializer&)
+        virtual StateBase* advance(Serializer&) OVERRIDE
         {
             delete this;
             return 0;
         }
     };
 
     template <typename T>
     class State : public StateBase {
     public:
         v8::Handle<T> composite() { return v8::Handle<T>::Cast(StateBase::composite()); }
@@ skipping 64 matching lines @@
 
         v8::Local<v8::Array> m_propertyNames;
 
     private:
         v8::Local<v8::Value> m_propertyName;
         unsigned m_index;
         unsigned m_numSerializedProperties;
         bool m_nameDone;
     };
 
-    class ObjectState : public AbstractObjectState {
+    class ObjectState FINAL : public AbstractObjectState {
     public:
         ObjectState(v8::Handle<v8::Object> object, StateBase* next)
             : AbstractObjectState(object, next)
         {
         }
 
-        virtual StateBase* advance(Serializer& serializer)
+        virtual StateBase* advance(Serializer& serializer) OVERRIDE
         {
             if (m_propertyNames.IsEmpty()) {
                 m_propertyNames = composite()->GetPropertyNames();
                 if (StateBase* newState = serializer.checkException(this))
                     return newState;
                 if (m_propertyNames.IsEmpty())
                     return serializer.handleError(InputError, "Empty property names cannot be cloned.", nextState());
             }
             return serializeProperties(false, serializer);
         }
 
     protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
+        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer) OVERRIDE
         {
             return serializer.writeObject(numProperties, this);
         }
     };
 
-    class DenseArrayState : public AbstractObjectState {
+    class DenseArrayState FINAL : public AbstractObjectState {
     public:
         DenseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next, v8::Isolate* isolate)
             : AbstractObjectState(array, next)
             , m_arrayIndex(0)
             , m_arrayLength(array->Length())
         {
             m_propertyNames = v8::Local<v8::Array>::New(isolate, propertyNames);
         }
 
-        virtual StateBase* advance(Serializer& serializer)
+        virtual StateBase* advance(Serializer& serializer) OVERRIDE
         {
             while (m_arrayIndex < m_arrayLength) {
                 v8::Handle<v8::Value> value = composite().As<v8::Array>()->Get(m_arrayIndex);
                 m_arrayIndex++;
                 if (StateBase* newState = serializer.checkException(this))
                     return newState;
                 if (StateBase* newState = serializer.doSerialize(value, this))
                     return newState;
             }
             return serializeProperties(true, serializer);
         }
 
     protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
+        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer) OVERRIDE
         {
             return serializer.writeDenseArray(numProperties, m_arrayLength, this);
         }
 
     private:
         uint32_t m_arrayIndex;
         uint32_t m_arrayLength;
     };
 
-    class SparseArrayState : public AbstractObjectState {
+    class SparseArrayState FINAL : public AbstractObjectState {
     public:
         SparseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next, v8::Isolate* isolate)
             : AbstractObjectState(array, next)
         {
             m_propertyNames = v8::Local<v8::Array>::New(isolate, propertyNames);
         }
 
-        virtual StateBase* advance(Serializer& serializer)
+        virtual StateBase* advance(Serializer& serializer) OVERRIDE
         {
             return serializeProperties(false, serializer);
         }
 
     protected:
-        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
+        virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer) OVERRIDE
         {
             return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
         }
     };
 
     StateBase* push(StateBase* state)
     {
         ASSERT(state);
         ++m_depth;
         return checkComposite(state) ? state : handleError(InputError, "Value being cloned is either cyclic or too deeply nested.", state);
@@ skipping 998 matching lines @@
     const unsigned m_length;
     unsigned m_position;
     uint32_t m_version;
     v8::Isolate* m_isolate;
     const BlobDataHandleMap& m_blobDataHandles;
 };
 
 
 typedef Vector<WTF::ArrayBufferContents, 1> ArrayBufferContentsArray;
 
-class Deserializer : public CompositeCreator {
+class Deserializer FINAL : public CompositeCreator {
 public:
     Deserializer(Reader& reader, MessagePortArray* messagePorts, ArrayBufferContentsArray* arrayBufferContents)
         : m_reader(reader)
         , m_transferredMessagePorts(messagePorts)
         , m_arrayBufferContents(arrayBufferContents)
         , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
         , m_version(0)
     {
     }
 
     v8::Handle<v8::Value> deserialize()
     {
         if (!m_reader.readVersion(m_version) || m_version > SerializedScriptValue::wireFormatVersion)
             return v8::Null(m_reader.getIsolate());
         m_reader.setVersion(m_version);
         v8::EscapableHandleScope scope(m_reader.getIsolate());
         while (!m_reader.isEof()) {
             if (!doDeserialize())
                 return v8::Null(m_reader.getIsolate());
         }
         if (stackDepth() != 1 || m_openCompositeReferenceStack.size())
             return v8::Null(m_reader.getIsolate());
         v8::Handle<v8::Value> result = scope.Escape(element(0));
         return result;
     }
 
-    virtual bool newSparseArray(uint32_t)
+    virtual bool newSparseArray(uint32_t) OVERRIDE
     {
         v8::Local<v8::Array> array = v8::Array::New(m_reader.isolate(), 0);
         openComposite(array);
         return true;
     }
 
-    virtual bool newDenseArray(uint32_t length)
+    virtual bool newDenseArray(uint32_t length) OVERRIDE
     {
         v8::Local<v8::Array> array = v8::Array::New(m_reader.isolate(), length);
         openComposite(array);
         return true;
     }
 
-    virtual bool consumeTopOfStack(v8::Handle<v8::Value>* object)
+    virtual bool consumeTopOfStack(v8::Handle<v8::Value>* object) OVERRIDE
     {
         if (stackDepth() < 1)
             return false;
         *object = element(stackDepth() - 1);
         pop(1);
         return true;
     }
 
-    virtual bool newObject()
+    virtual bool newObject() OVERRIDE
     {
         v8::Local<v8::Object> object = v8::Object::New(m_reader.isolate());
         if (object.IsEmpty())
             return false;
         openComposite(object);
         return true;
     }
 
-    virtual bool completeObject(uint32_t numProperties, v8::Handle<v8::Value>* value)
+    virtual bool completeObject(uint32_t numProperties, v8::Handle<v8::Value>* value) OVERRIDE
     {
         v8::Local<v8::Object> object;
         if (m_version > 0) {
             v8::Local<v8::Value> composite;
             if (!closeComposite(&composite))
                 return false;
             object = composite.As<v8::Object>();
         } else {
             object = v8::Object::New(m_reader.isolate());
         }
         if (object.IsEmpty())
             return false;
         return initializeObject(object, numProperties, value);
     }
 
-    virtual bool completeSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
+    virtual bool completeSparseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value) OVERRIDE
     {
         v8::Local<v8::Array> array;
         if (m_version > 0) {
             v8::Local<v8::Value> composite;
             if (!closeComposite(&composite))
                 return false;
             array = composite.As<v8::Array>();
         } else {
             array = v8::Array::New(m_reader.isolate());
         }
         if (array.IsEmpty())
             return false;
         return initializeObject(array, numProperties, value);
     }
 
-    virtual bool completeDenseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value)
+    virtual bool completeDenseArray(uint32_t numProperties, uint32_t length, v8::Handle<v8::Value>* value) OVERRIDE
     {
         v8::Local<v8::Array> array;
         if (m_version > 0) {
             v8::Local<v8::Value> composite;
             if (!closeComposite(&composite))
                 return false;
             array = composite.As<v8::Array>();
         }
         if (array.IsEmpty())
             return false;
         if (!initializeObject(array, numProperties, value))
             return false;
         if (length > stackDepth())
             return false;
         for (unsigned i = 0, stackPos = stackDepth() - length; i < length; i++, stackPos++) {
             v8::Local<v8::Value> elem = element(stackPos);
             if (!elem->IsUndefined())
                 array->Set(i, elem);
         }
         pop(length);
         return true;
     }
 
-    virtual void pushObjectReference(const v8::Handle<v8::Value>& object)
+    virtual void pushObjectReference(const v8::Handle<v8::Value>& object) OVERRIDE
     {
         m_objectPool.append(object);
     }
 
-    virtual bool tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>* object)
+    virtual bool tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>* object) OVERRIDE
     {
         if (!m_transferredMessagePorts)
             return false;
         if (index >= m_transferredMessagePorts->size())
             return false;
         *object = toV8(m_transferredMessagePorts->at(index).get(), v8::Handle<v8::Object>(), m_reader.getIsolate());
         return true;
     }
 
-    virtual bool tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>* object)
+    virtual bool tryGetTransferredArrayBuffer(uint32_t index, v8::Handle<v8::Value>* object) OVERRIDE
     {
         if (!m_arrayBufferContents)
             return false;
         if (index >= m_arrayBuffers.size())
             return false;
         v8::Handle<v8::Object> result = m_arrayBuffers.at(index);
         if (result.IsEmpty()) {
             RefPtr<ArrayBuffer> buffer = ArrayBuffer::create(m_arrayBufferContents->at(index));
             buffer->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instanceTemplate());
             m_reader.isolate()->AdjustAmountOfExternalAllocatedMemory(buffer->byteLength());
             result = toV8Object(buffer.get(), m_reader.getIsolate());
             m_arrayBuffers[index] = result;
         }
         *object = result;
         return true;
     }
 
-    virtual bool tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>* object)
+    virtual bool tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>* object) OVERRIDE
     {
         if (reference >= m_objectPool.size())
             return false;
         *object = m_objectPool[reference];
         return object;
     }
 
-    virtual uint32_t objectReferenceCount()
+    virtual uint32_t objectReferenceCount() OVERRIDE
     {
         return m_objectPool.size();
     }
 
 private:
     bool initializeObject(v8::Handle<v8::Object> object, uint32_t numProperties, v8::Handle<v8::Value>* value)
     {
         unsigned length = 2 * numProperties;
         if (length > stackDepth())
             return false;
@@ skipping 291 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace WebCore