Structured cloning: improve DataCloneError reporting.

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 19 matching lines @@
 
 #include "config.h"
 #include "bindings/v8/SerializedScriptValue.h"
 
 #include "V8Blob.h"
 #include "V8DOMFileSystem.h"
 #include "V8File.h"
 #include "V8FileList.h"
 #include "V8ImageData.h"
 #include "V8MessagePort.h"
+#include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ScriptScope.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
 #include "bindings/v8/V8Utilities.h"
 #include "bindings/v8/custom/V8ArrayBufferCustom.h"
 #include "bindings/v8/custom/V8ArrayBufferViewCustom.h"
 #include "bindings/v8/custom/V8DataViewCustom.h"
 #include "bindings/v8/custom/V8Float32ArrayCustom.h"
 #include "bindings/v8/custom/V8Float64ArrayCustom.h"
 #include "bindings/v8/custom/V8Int16ArrayCustom.h"
@@ skipping 646 matching lines @@
     return wrapper.As<v8::ArrayBuffer>();
 }
 
 class Serializer {
     class StateBase;
 public:
     enum Status {
         Success,
         InputError,
         DataCloneError,
-        InvalidStateError,
-        JSException,
-        JSFailure
+        JSException
     };
 
     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_status(Success)
         , m_nextObjectReference(0)
         , m_blobDataHandles(blobDataHandles)
         , m_isolate(isolate)
@@ skipping 16 matching lines @@
     Status serialize(v8::Handle<v8::Value> value)
     {
         v8::HandleScope scope(m_isolate);
         m_writer.writeVersion();
         StateBase* state = doSerialize(value, 0);
         while (state)
             state = state->advance(*this);
         return m_status;
     }
 
+    String errorMessage() { return m_errorMessage; }
+
     // Functions used by serialization states.
     StateBase* doSerialize(v8::Handle<v8::Value>, StateBase* next);
 
     StateBase* doSerializeArrayBuffer(v8::Handle<v8::Value> arrayBuffer, StateBase* 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);
+        return m_tryCatch.HasCaught() ? handleError(JSException, "", state) : 0;
     }
 
     StateBase* writeObject(uint32_t numProperties, StateBase* state)
     {
         m_writer.writeObject(numProperties);
         return pop(state);
     }
 
     StateBase* writeSparseArray(uint32_t numProperties, uint32_t length, StateBase* state)
     {
@@ skipping 82 matching lines @@
         virtual StateBase* objectDone(unsigned numProperties, Serializer&) = 0;
 
         StateBase* serializeProperties(bool ignoreIndexed, Serializer& serializer)
         {
             while (m_index < m_propertyNames->Length()) {
                 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);
+                        return serializer.handleError(InputError, "Empty property names cannot be cloned.", 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;
                     if (hasStringProperty || (hasIndexedProperty && !ignoreIndexed))
                         m_propertyName = propertyName;
                     else {
                         ++m_index;
@@ skipping 38 matching lines @@
         {
         }
 
         virtual StateBase* advance(Serializer& serializer)
         {
             if (m_propertyNames.IsEmpty()) {
                 m_propertyNames = composite()->GetPropertyNames();
                 if (StateBase* newState = serializer.checkException(this))
                     return newState;
                 if (m_propertyNames.IsEmpty())
-                    return serializer.reportFailure(this);
+                    return serializer.handleError(InputError, "Empty property names cannot be cloned.", nextState());
             }
             return serializeProperties(false, serializer);
         }
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeObject(numProperties, this);
         }
     };
@@ skipping 49 matching lines @@
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
         }
     };
 
     StateBase* push(StateBase* state)
     {
         ASSERT(state);
         ++m_depth;
-        return checkComposite(state) ? state : handleError(InputError, state);
+        return checkComposite(state) ? state : handleError(InputError, "Value being cloned is either cyclic or too deeply nested.", state);
     }
 
     StateBase* pop(StateBase* state)
     {
         ASSERT(state);
         --m_depth;
         StateBase* next = state->nextState();
         delete state;
         return next;
     }
 
-    StateBase* handleError(Status errorStatus, StateBase* state)
+    StateBase* handleError(Status errorStatus, const String& message, StateBase* state)
     {
         ASSERT(errorStatus != Success);
         m_status = errorStatus;
+        m_errorMessage = message;
         while (state) {
             StateBase* tmp = state->nextState();
             delete state;
             state = tmp;
         }
         return new ErrorState;
     }
 
     bool checkComposite(StateBase* top)
     {
@@ skipping 46 matching lines @@
         m_writer.writeBlob(blob->uuid(), blob->type(), blob->size());
         m_blobDataHandles.add(blob->uuid(), blob->blobDataHandle());
     }
 
     StateBase* writeDOMFileSystem(v8::Handle<v8::Value> value, StateBase* next)
     {
         DOMFileSystem* fs = V8DOMFileSystem::toNative(value.As<v8::Object>());
         if (!fs)
             return 0;
         if (!fs->clonable())
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "A FileSystem object could not be cloned.", next);
         m_writer.writeDOMFileSystem(fs->type(), fs->name(), fs->rootURL().string());
         return 0;
     }
 
     void writeFile(v8::Handle<v8::Value> value)
     {
         File* file = V8File::toNative(value.As<v8::Object>());
         if (!file)
             return;
         m_writer.writeFile(*file);
@@ skipping 26 matching lines @@
         m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags());
     }
 
     StateBase* writeAndGreyArrayBufferView(v8::Handle<v8::Object> object, StateBase* next)
     {
         ASSERT(!object.IsEmpty());
         ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(object);
         if (!arrayBufferView)
             return 0;
         if (!arrayBufferView->buffer())
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         v8::Handle<v8::Value> underlyingBuffer = toV8(arrayBufferView->buffer(), v8::Handle<v8::Object>(), m_writer.getIsolate());
         if (underlyingBuffer.IsEmpty())
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         StateBase* stateOut = doSerializeArrayBuffer(underlyingBuffer, next);
         if (stateOut)
             return stateOut;
         m_writer.writeArrayBufferView(*arrayBufferView);
         // This should be safe: we serialize something that we know to be a wrapper (see
         // the toV8 call above), so the call to doSerializeArrayBuffer should neither
         // cause the system stack to overflow nor should it have potential to reach
         // this ArrayBufferView again.
         //
         // We do need to grey the underlying buffer before we grey its view, however;
         // ArrayBuffers may be shared, so they need to be given reference IDs, and an
         // ArrayBufferView cannot be constructed without a corresponding ArrayBuffer
         // (or without an additional tag that would allow us to do two-stage construction
         // like we do for Objects and Arrays).
         greyObject(object);
         return 0;
     }
 
     StateBase* writeArrayBuffer(v8::Handle<v8::Value> value, StateBase* next)
     {
         ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
-            return handleError(InvalidStateError, next);
+            return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         ASSERT(!m_transferredArrayBuffers.contains(value.As<v8::Object>()));
         m_writer.writeArrayBuffer(*arrayBuffer);
         return 0;
     }
 
     StateBase* writeTransferredArrayBuffer(v8::Handle<v8::Value> value, uint32_t index, StateBase* next)
     {
         ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         m_writer.writeTransferredArrayBuffer(index);
         return 0;
     }
 
     static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
     {
         // Let K be the cost of serializing all property values that are there
         // Cost of serializing sparsely: 5*propertyCount + K (5 bytes per uint32_t key)
         // Cost of serializing densely: K + 1*(length - propertyCount) (1 byte for all properties that are not there)
         // so densely is better than sparsly whenever 6*propertyCount > length
@@ skipping 29 matching lines @@
     {
         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;
     Status m_status;
+    String m_errorMessage;
     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::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());
         m_writer.writeObjectReference(objectReference);
-    } else if (value.IsEmpty())
-        return reportFailure(next);
-    else if (value->IsUndefined())
+    } else if (value.IsEmpty()) {
+        return handleError(InputError, "The empty property name cannot be cloned.", next);
+    } else if (value->IsUndefined())
         m_writer.writeUndefined();
     else if (value->IsNull())
         m_writer.writeNull();
     else if (value->IsTrue())
         m_writer.writeTrue();
     else if (value->IsFalse())
         m_writer.writeFalse();
     else if (value->IsInt32())
         m_writer.writeInt32(value->Int32Value());
     else if (value->IsUint32())
         m_writer.writeUint32(value->Uint32Value());
     else if (value->IsNumber())
         m_writer.writeNumber(value.As<v8::Number>()->Value());
     else if (V8ArrayBufferView::hasInstance(value, m_isolate, currentWorldType))
         return writeAndGreyArrayBufferView(value.As<v8::Object>(), next);
     else if (value->IsString())
         writeString(value);
     else if (V8MessagePort::hasInstance(value, m_isolate, currentWorldType)) {
         uint32_t messagePortIndex;
         if (m_transferredMessagePorts.tryGet(value.As<v8::Object>(), &messagePortIndex))
                 m_writer.writeTransferredMessagePort(messagePortIndex);
             else
-                return handleError(DataCloneError, next);
+                return handleError(DataCloneError, "A MessagePort could not be cloned.", next);
     } else if (V8ArrayBuffer::hasInstance(value, m_isolate, currentWorldType) && m_transferredArrayBuffers.tryGet(value.As<v8::Object>(), &arrayBufferIndex))
         return writeTransferredArrayBuffer(value, arrayBufferIndex, next);
     else {
         v8::Handle<v8::Object> jsObject = value.As<v8::Object>();
         if (jsObject.IsEmpty())
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "An object could not be cloned.", next);
         greyObject(jsObject);
         if (value->IsDate())
             m_writer.writeDate(value->NumberValue());
         else if (value->IsStringObject())
             writeStringObject(value);
         else if (value->IsNumberObject())
             writeNumberObject(value);
         else if (value->IsBooleanObject())
             writeBooleanObject(value);
         else if (value->IsArray()) {
             return startArrayState(value.As<v8::Array>(), next);
         } else if (V8File::hasInstance(value, m_isolate, currentWorldType))
             writeFile(value);
         else if (V8Blob::hasInstance(value, m_isolate, currentWorldType))
             writeBlob(value);
         else if (V8DOMFileSystem::hasInstance(value, m_isolate, currentWorldType))
             return writeDOMFileSystem(value, next);
         else if (V8FileList::hasInstance(value, m_isolate, currentWorldType))
             writeFileList(value);
         else if (V8ImageData::hasInstance(value, m_isolate, currentWorldType))
             writeImageData(value);
         else if (value->IsRegExp())
             writeRegExp(value);
         else if (V8ArrayBuffer::hasInstance(value, m_isolate, currentWorldType))
             return writeArrayBuffer(value, next);
         else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
-                return handleError(DataCloneError, next);
+                return handleError(DataCloneError, "An object could not be cloned.", next);
             return startObjectState(jsObject, next);
         } else
-            return handleError(DataCloneError, next);
+            return handleError(DataCloneError, "A value could not be cloned.", next);
     }
     return 0;
 }
 
 // Interface used by Reader to create objects of composite types.
 class CompositeCreator {
 public:
     virtual ~CompositeCreator() { }
 
     virtual bool consumeTopOfStack(v8::Handle<v8::Value>*) = 0;
@@ skipping 941 matching lines @@
     Vector<v8::Handle<v8::Value> > m_objectPool;
     Vector<uint32_t> m_openCompositeReferenceStack;
     MessagePortArray* m_transferredMessagePorts;
     ArrayBufferContentsArray* m_arrayBufferContents;
     Vector<v8::Handle<v8::Object> > m_arrayBuffers;
     uint32_t m_version;
 };
 
 } // namespace
 
-PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, bool& didThrow, v8::Isolate* isolate)
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, ExceptionState& exceptionState, v8::Isolate* isolate)
 {
-    return adoptRef(new SerializedScriptValue(value, messagePorts, arrayBuffers, didThrow, isolate));
+    return adoptRef(new SerializedScriptValue(value, messagePorts, arrayBuffers, exceptionState, isolate));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::createAndSwallowExceptions(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
-    bool didThrow;
-    return adoptRef(new SerializedScriptValue(value, 0, 0, didThrow, isolate, DoNotThrowExceptions));
+    TrackExceptionState exceptionState;
+    return adoptRef(new SerializedScriptValue(value, 0, 0, exceptionState, isolate));
 }
 
-PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(const ScriptValue& value, bool& didThrow, ScriptState* state)
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(const ScriptValue& value, ExceptionState& exceptionState, ScriptState* state)
 {
     ScriptScope scope(state);
-    return adoptRef(new SerializedScriptValue(value.v8Value(), 0, 0, didThrow, state->isolate()));
+    return adoptRef(new SerializedScriptValue(value.v8Value(), 0, 0, exceptionState, state->isolate()));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::createFromWire(const String& data)
 {
     return adoptRef(new SerializedScriptValue(data));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::createFromWireBytes(const Vector<uint8_t>& data)
 {
     // Decode wire data from big endian to host byte order.
@@ skipping 80 matching lines @@
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     Vector<DOMDataStore*>& allStores = V8PerIsolateData::from(isolate)->allStores();
     for (size_t i = 0; i < allStores.size(); i++) {
         v8::Handle<v8::Object> wrapper = allStores[i]->get<V8ArrayBufferView>(object, isolate);
         if (!wrapper.IsEmpty())
             wrapper->SetIndexedPropertiesToExternalArrayData(0, v8::kExternalByteArray, 0);
     }
 }
 
-PassOwnPtr<SerializedScriptValue::ArrayBufferContentsArray> SerializedScriptValue::transferArrayBuffers(ArrayBufferArray& arrayBuffers, bool& didThrow, v8::Isolate* isolate)
+PassOwnPtr<SerializedScriptValue::ArrayBufferContentsArray> SerializedScriptValue::transferArrayBuffers(ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState, v8::Isolate* isolate)
 {
     ASSERT(arrayBuffers.size());
 
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (arrayBuffers[i]->isNeutered()) {
-            setDOMException(InvalidStateError, isolate);
-            didThrow = true;
+            exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is already neutered.");
             return nullptr;
         }
     }
 
     OwnPtr<ArrayBufferContentsArray> contents = adoptPtr(new ArrayBufferContentsArray(arrayBuffers.size()));
 
     HashSet<ArrayBuffer*> visited;
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         Vector<RefPtr<ArrayBufferView> > neuteredViews;
 
         if (visited.contains(arrayBuffers[i].get()))
             continue;
         visited.add(arrayBuffers[i].get());
 
         bool result = arrayBuffers[i]->transfer(contents->at(i), neuteredViews);
         if (!result) {
-            setDOMException(InvalidStateError, isolate);
-            didThrow = true;
+            exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " could not be transferred.");
             return nullptr;
         }
 
         neuterBinding(arrayBuffers[i].get());
         for (size_t j = 0; j < neuteredViews.size(); j++)
             neuterBinding(neuteredViews[j].get());
     }
     return contents.release();
 }
 
-SerializedScriptValue::SerializedScriptValue(v8::Handle<v8::Value> value, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, bool& didThrow, v8::Isolate* isolate, ExceptionPolicy policy)
+SerializedScriptValue::SerializedScriptValue(v8::Handle<v8::Value> value, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, ExceptionState& exceptionState, v8::Isolate* isolate)
     : m_externallyAllocatedMemory(0)
 {
-    didThrow = false;
     Writer writer(isolate);
     Serializer::Status status;
+    String errorMessage;
     {
         v8::TryCatch tryCatch;
         Serializer serializer(writer, messagePorts, arrayBuffers, m_blobDataHandles, tryCatch, isolate);
         status = serializer.serialize(value);
         if (status == Serializer::JSException) {
-            didThrow = true;
             // If there was a JS exception thrown, re-throw it.
-            if (policy == ThrowExceptions)
-                tryCatch.ReThrow();
+            exceptionState.rethrowV8Exception(tryCatch.Exception());
             return;
         }
+        errorMessage = serializer.errorMessage();
     }
     switch (status) {
     case Serializer::InputError:
     case Serializer::DataCloneError:
-        // If there was an input error, throw a new exception outside
-        // of the TryCatch scope.
-        didThrow = true;
-        if (policy == ThrowExceptions)
-            setDOMException(DataCloneError, isolate);
-        return;
-    case Serializer::InvalidStateError:
-        didThrow = true;
-        if (policy == ThrowExceptions)
-            setDOMException(InvalidStateError, isolate);
-        return;
-    case Serializer::JSFailure:
-        // If there was a JS failure (but no exception), there's not
-        // much we can do except for unwinding the C++ stack by
-        // pretending there was a JS exception.
-        didThrow = true;
+        exceptionState.throwDOMException(DataCloneError, errorMessage);
         return;
     case Serializer::Success:
         m_data = writer.takeWireString();
         ASSERT(m_data.impl()->hasOneRef());
         if (arrayBuffers && arrayBuffers->size())
-            m_arrayBufferContentsArray = transferArrayBuffers(*arrayBuffers, didThrow, isolate);
+            m_arrayBufferContentsArray = transferArrayBuffers(*arrayBuffers, exceptionState, isolate);
         return;
     case Serializer::JSException:
-        // We should never get here because this case was handled above.
+        ASSERT_NOT_REACHED();
         break;
     }
     ASSERT_NOT_REACHED();
 }
 
 SerializedScriptValue::SerializedScriptValue(const String& wireData)
     : m_externallyAllocatedMemory(0)
 {
     m_data = wireData.isolatedCopy();
 }
@@ skipping 35 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