Remove structured cloning restriction over accessor properties.

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 679 matching lines @@
         DataCloneError,
         InvalidStateError,
         JSException,
         JSFailure
     };
 
     Serializer(Writer& writer, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, v8::Isolate* isolate)
         : m_writer(writer)
         , m_tryCatch(tryCatch)
         , m_depth(0)
-        , m_execDepth(0)
         , m_status(Success)
         , m_nextObjectReference(0)
         , m_blobDataHandles(blobDataHandles)
         , m_isolate(isolate)
     {
         ASSERT(!tryCatch.HasCaught());
         if (messagePorts) {
             for (size_t i = 0; i < messagePorts->size(); i++)
                 m_transferredMessagePorts.set(toV8Object(messagePorts->at(i).get(), m_writer.getIsolate()), i);
         }
@@ skipping 13 matching lines @@
         m_writer.writeVersion();
         StateBase* state = doSerialize(value, 0);
         while (state)
             state = state->advance(*this);
         return m_status;
     }
 
     // Functions used by serialization states.
     StateBase* doSerialize(v8::Handle<v8::Value>, StateBase* next);
 
-    // The serializer workhorse, no stack depth check.
-    StateBase* doSerializeImpl(v8::Handle<v8::Value>, StateBase* next);
-
     StateBase* doSerializeArrayBuffer(v8::Handle<v8::Value> arrayBuffer, StateBase* next)
     {
-        return doSerializeImpl(arrayBuffer, next);
+        return doSerialize(arrayBuffer, next);
     }
 
     StateBase* checkException(StateBase* state)
     {
         return m_tryCatch.HasCaught() ? handleError(JSException, state) : 0;
     }
 
     StateBase* reportFailure(StateBase* state)
     {
         return handleError(JSFailure, state);
@@ skipping 78 matching lines @@
         }
     };
 
     class AbstractObjectState : public State<v8::Object> {
     public:
         AbstractObjectState(v8::Handle<v8::Object> object, StateBase* next)
             : State<v8::Object>(object, next)
             , m_index(0)
             , m_numSerializedProperties(0)
             , m_nameDone(false)
-            , m_isSerializingAccessor(false)
         {
         }
 
-        virtual uint32_t execDepth() const { return m_isSerializingAccessor ? 1 : 0; }
-
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer&) = 0;
 
         StateBase* serializeProperties(bool ignoreIndexed, Serializer& serializer)
         {
-            m_isSerializingAccessor = false;
             while (m_index < m_propertyNames->Length()) {
-                bool isAccessor = false;
                 if (!m_nameDone) {
                     v8::Local<v8::Value> propertyName = m_propertyNames->Get(m_index);
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
                     if (propertyName.IsEmpty())
                         return serializer.reportFailure(this);
                     bool hasStringProperty = propertyName->IsString() && composite()->HasRealNamedProperty(propertyName.As<v8::String>());
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
                     bool hasIndexedProperty = !hasStringProperty && propertyName->IsUint32() && composite()->HasRealIndexedProperty(propertyName->Uint32Value());
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
-                    isAccessor = hasStringProperty && composite()->HasRealNamedCallbackProperty(propertyName.As<v8::String>());
-                    if (StateBase* newState = serializer.checkException(this))
-                        return newState;
                     if (hasStringProperty || (hasIndexedProperty && !ignoreIndexed))
                         m_propertyName = propertyName;
                     else {
                         ++m_index;
                         continue;
                     }
                 }
                 ASSERT(!m_propertyName.IsEmpty());
                 if (!m_nameDone) {
                     m_nameDone = true;
                     if (StateBase* newState = serializer.doSerialize(m_propertyName, this))
                         return newState;
                 }
                 v8::Local<v8::Value> value = composite()->Get(m_propertyName);
                 if (StateBase* newState = serializer.checkException(this))
                     return newState;
                 m_nameDone = false;
                 m_propertyName.Clear();
                 ++m_index;
                 ++m_numSerializedProperties;
-                m_isSerializingAccessor = isAccessor;
                 // If we return early here, it's either because we have pushed a new state onto the
                 // serialization state stack or because we have encountered an error (and in both cases
-                // we are unwinding the native stack). We reset m_isSerializingAccessor at the beginning
-                // of advance() for this case (because advance() will be called on us again once we
-                // are the top of the stack).
+                // we are unwinding the native stack).
                 if (StateBase* newState = serializer.doSerialize(value, this))
                     return newState;
-                m_isSerializingAccessor = false;
             }
             return objectDone(m_numSerializedProperties, serializer);
         }
 
         v8::Local<v8::Array> m_propertyNames;
 
     private:
         v8::Local<v8::Value> m_propertyName;
         unsigned m_index;
         unsigned m_numSerializedProperties;
         bool m_nameDone;
-        // Used along with execDepth() to determine the number of
-        // accessors under which the serializer is currently serializing.
-        bool m_isSerializingAccessor;
     };
 
     class ObjectState : public AbstractObjectState {
     public:
         ObjectState(v8::Handle<v8::Object> object, StateBase* next)
             : AbstractObjectState(object, next)
         {
         }
 
         virtual StateBase* advance(Serializer& serializer)
@@ skipping 65 matching lines @@
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
         }
     };
 
     StateBase* push(StateBase* state)
     {
         ASSERT(state);
-        if (state->nextState())
-            m_execDepth += state->nextState()->execDepth();
         ++m_depth;
         return checkComposite(state) ? state : handleError(InputError, state);
     }
 
     StateBase* pop(StateBase* state)
     {
         ASSERT(state);
         --m_depth;
         StateBase* next = state->nextState();
-        if (next)
-            m_execDepth -= next->execDepth();
         delete state;
         return next;
     }
 
     StateBase* handleError(Status errorStatus, StateBase* state)
     {
         ASSERT(errorStatus != Success);
         m_status = errorStatus;
         while (state) {
             StateBase* tmp = state->nextState();
             delete state;
             state = tmp;
-            if (state)
-                m_execDepth -= state->execDepth();
         }
         return new ErrorState;
     }
 
     bool checkComposite(StateBase* top)
     {
         ASSERT(top);
         if (m_depth > maxDepth)
             return false;
         if (!shouldCheckForCycles(m_depth))
@@ skipping 178 matching lines @@
     void greyObject(const v8::Handle<v8::Object>& object)
     {
         ASSERT(!m_objectPool.contains(object));
         uint32_t objectReference = m_nextObjectReference++;
         m_objectPool.set(object, objectReference);
     }
 
     Writer& m_writer;
     v8::TryCatch& m_tryCatch;
     int m_depth;
-    int m_execDepth;
     Status m_status;
     typedef V8ObjectMap<v8::Object, uint32_t> ObjectPool;
     ObjectPool m_objectPool;
     ObjectPool m_transferredMessagePorts;
     ObjectPool m_transferredArrayBuffers;
     uint32_t m_nextObjectReference;
     BlobDataHandleMap& m_blobDataHandles;
     v8::Isolate* m_isolate;
 };
 
-Serializer::StateBase* Serializer::doSerializeImpl(v8::Handle<v8::Value> value, StateBase* next)
+Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, StateBase* next)
 {
     m_writer.writeReferenceCount(m_nextObjectReference);
     uint32_t objectReference;
     uint32_t arrayBufferIndex;
     WrapperWorldType currentWorldType = worldType(m_isolate);
     if ((value->IsObject() || value->IsDate() || value->IsRegExp())
         && m_objectPool.tryGet(value.As<v8::Object>(), &objectReference)) {
         // Note that IsObject() also detects wrappers (eg, it will catch the things
         // that we grey and write below).
         ASSERT(!value->IsString());
@@ skipping 58 matching lines @@
         else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
                 return handleError(DataCloneError, next);
             return startObjectState(jsObject, next);
         } else
             return handleError(DataCloneError, next);
     }
     return 0;
 }
 
-Serializer::StateBase* Serializer::doSerialize(v8::Handle<v8::Value> value, StateBase* next)
-{
-    if (m_execDepth + (next ? next->execDepth() : 0) > 1) {
-        m_writer.writeNull();
-        return 0;
-    }
-    return doSerializeImpl(value, next);
-}
-
 // Interface used by Reader to create objects of composite types.
 class CompositeCreator {
 public:
     virtual ~CompositeCreator() { }
 
     virtual bool consumeTopOfStack(v8::Handle<v8::Value>*) = 0;
     virtual uint32_t objectReferenceCount() = 0;
     virtual void pushObjectReference(const v8::Handle<v8::Value>&) = 0;
     virtual bool tryGetObjectFromObjectReference(uint32_t reference, v8::Handle<v8::Value>*) = 0;
     virtual bool tryGetTransferredMessagePort(uint32_t index, v8::Handle<v8::Value>*) = 0;
@@ skipping 1172 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