Throw DataCloneError on cloning closed Blobs/Files.

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 1034 matching lines @@
         v8::Handle<v8::NumberObject> numberObject = value.As<v8::NumberObject>();
         m_writer.writeNumberObject(numberObject->ValueOf());
     }
 
     void writeBooleanObject(v8::Handle<v8::Value> value)
     {
         v8::Handle<v8::BooleanObject> booleanObject = value.As<v8::BooleanObject>();
         m_writer.writeBooleanObject(booleanObject->ValueOf());
     }
 
-    void writeBlob(v8::Handle<v8::Value> value)
+    StateBase* writeBlob(v8::Handle<v8::Value> value, StateBase* next)
     {
         Blob* blob = V8Blob::toNative(value.As<v8::Object>());
         if (!blob)
-            return;
+            return 0;
+        if (blob->hasBeenClosed())
+            return handleError(DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
         m_writer.writeBlob(blob->uuid(), blob->type(), blob->size());
         m_blobDataHandles.add(blob->uuid(), blob->blobDataHandle());
+        return 0;
     }
 
     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, "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)
+    StateBase* writeFile(v8::Handle<v8::Value> value, StateBase* next)
     {
         File* file = V8File::toNative(value.As<v8::Object>());
         if (!file)
-            return;
+            return 0;
+        if (file->hasBeenClosed())
+            return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
         m_writer.writeFile(*file);
         m_blobDataHandles.add(file->uuid(), file->blobDataHandle());
+        return 0;
     }
 
     void writeFileList(v8::Handle<v8::Value> value)
     {
         FileList* fileList = V8FileList::toNative(value.As<v8::Object>());
         if (!fileList)
             return;
         m_writer.writeFileList(*fileList);
         unsigned length = fileList->length();
         for (unsigned i = 0; i < length; ++i)
@@ skipping 181 matching lines @@
             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))
-            writeFile(value);
+            return writeFile(value, next);
         else if (V8Blob::hasInstance(value, m_isolate))
-            writeBlob(value);
+            return writeBlob(value, next);
         else if (V8DOMFileSystem::hasInstance(value, m_isolate))
             return writeDOMFileSystem(value, next);
         else if (V8FileList::hasInstance(value, m_isolate))
             writeFileList(value);
         else if (V8ImageData::hasInstance(value, m_isolate))
             writeImageData(value);
         else if (value->IsRegExp())
             writeRegExp(value);
         else if (V8ArrayBuffer::hasInstance(value, m_isolate))
             return writeArrayBuffer(value, next);
@@ skipping 1208 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