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 670 matching lines @@
     return wrapper.As<v8::ArrayBuffer>();
 }
 
 class Serializer {
     class StateBase;
 public:
     enum Status {
         Success,
         InputError,
         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_status(Success)
         , m_nextObjectReference(0)
@@ skipping 422 matching lines @@
         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, 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;
@@ skipping 1069 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, ExceptionState& exceptionState, v8::Isolate* isolate)
+{
+    bool didThrow;
+    return adoptRef(new SerializedScriptValue(value, messagePorts, arrayBuffers, didThrow, &exceptionState, isolate));
+}
+
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(v8::Handle<v8::Value> value, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, bool& didThrow, v8::Isolate* isolate)
 {
-    return adoptRef(new SerializedScriptValue(value, messagePorts, arrayBuffers, didThrow, isolate));
+    return adoptRef(new SerializedScriptValue(value, messagePorts, arrayBuffers, didThrow, 0, 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));
+    return adoptRef(new SerializedScriptValue(value, 0, 0, didThrow, 0, isolate, DoNotThrowExceptions));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create(const ScriptValue& value, bool& didThrow, ScriptState* state)
 {
     ScriptScope scope(state);
-    return adoptRef(new SerializedScriptValue(value.v8Value(), 0, 0, didThrow, state->isolate()));
+    return adoptRef(new SerializedScriptValue(value.v8Value(), 0, 0, didThrow, 0, 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, bool& didThrow, ExceptionState* exceptionState, v8::Isolate* isolate)
 {
     ASSERT(arrayBuffers.size());
 
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (arrayBuffers[i]->isNeutered()) {
-            setDOMException(InvalidStateError, isolate);
+            if (exceptionState)
+                exceptionState->throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is already neutered.");
+            else
+                setDOMException(DataCloneError, isolate);
             didThrow = true;
             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);
+            if (exceptionState)
+                exceptionState->throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " could not be transferred.");
+            else
+                setDOMException(DataCloneError, isolate);
             didThrow = true;
             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, bool& didThrow, ExceptionState* exceptionState, v8::Isolate* isolate, ExceptionPolicy policy)
     : m_externallyAllocatedMemory(0)
 {
     didThrow = false;
     Writer writer(isolate);
     Serializer::Status status;
     {
         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();
+            if (policy == ThrowExceptions) {
+                if (exceptionState)
+                    exceptionState->setException(tryCatch.Exception());
+                else
+                    tryCatch.ReThrow();
+            }
             return;
         }
     }
     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);
+        if (policy == ThrowExceptions) {
+            if (exceptionState) {
+                // FIXME possible to generate a better error messsage than this?
+                exceptionState->throwDOMException(DataCloneError, "An object could not be cloned.");
+            } else {
+                setDOMException(DataCloneError, 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;
         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, didThrow, exceptionState, isolate);
         return;
     case Serializer::JSException:
         // We should never get here because this case was handled above.
         break;
     }
     ASSERT_NOT_REACHED();
 }
 
 SerializedScriptValue::SerializedScriptValue(const String& wireData)
     : m_externallyAllocatedMemory(0)
@@ skipping 38 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