compositor-worker: Introduce CompositorProxy.

Source/bindings/core/v8/ScriptValueSerializer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
+#include "bindings/core/v8/V8CompositorProxy.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
+#include "core/dom/CompositorProxy.h"
 #include "core/dom/DOMDataView.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebBlobInfo.h"
 #include "wtf/DateMath.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 
@@ skipping 166 matching lines @@
     doWriteUint64(size);
 }
 
 void SerializedScriptValueWriter::writeBlobIndex(int blobIndex)
 {
     ASSERT(blobIndex >= 0);
     append(BlobIndexTag);
     doWriteUint32(blobIndex);
 }
 
+void SerializedScriptValueWriter::writeCompositorProxy(const CompositorProxy& compositorProxy)
+{
+    append(CompositorProxyTag);
+    doWriteUint64(compositorProxy.elementId());
+    doWriteUint32(compositorProxy.bitfieldsSupported());
+}
+
 void SerializedScriptValueWriter::writeFile(const File& file)
 {
     append(FileTag);
     doWriteFile(file);
 }
 
 void SerializedScriptValueWriter::writeFileIndex(int blobIndex)
 {
     append(FileIndexTag);
     doWriteUint32(blobIndex);
@@ skipping 491 matching lines @@
         } else if (V8Blob::hasInstance(value, isolate())) {
             return writeBlob(value, next);
         } else if (V8FileList::hasInstance(value, isolate())) {
             return writeFileList(value, next);
         } else if (V8ImageData::hasInstance(value, isolate())) {
             writeImageData(value);
         } else if (value->IsRegExp()) {
             writeRegExp(value);
         } else if (V8ArrayBuffer::hasInstance(value, isolate())) {
             return writeArrayBuffer(value, next);
+        } else if (V8CompositorProxy::hasInstance(value, isolate())) {
+            return writeCompositorProxy(value, next);
         } else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
                 return handleError(DataCloneError, "An object could not be cloned.", next);
             return startObjectState(jsObject, next);
         } else {
             return handleError(DataCloneError, "A value could not be cloned.", next);
         }
     }
     return 0;
 }
@@ skipping 91 matching lines @@
         return handleError(DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
     m_blobDataHandles.set(blob->uuid(), blob->blobDataHandle());
     if (appendBlobInfo(blob->uuid(), blob->type(), blob->size(), &blobIndex))
         m_writer.writeBlobIndex(blobIndex);
     else
         m_writer.writeBlob(blob->uuid(), blob->type(), blob->size());
     return 0;
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeCompositorProxy(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
+{
+    CompositorProxy* compositorProxy = V8CompositorProxy::toImpl(value.As<v8::Object>());
+    if (!compositorProxy)
+        return nullptr;
+    m_writer.writeCompositorProxy(*compositorProxy);
+    return nullptr;
+}
+
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeFile(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     File* file = V8File::toImpl(value.As<v8::Object>());
     if (!file)
         return 0;
     if (file->hasBeenClosed())
         return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
     m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
     if (appendFileInfo(file, &blobIndex)) {
@@ skipping 257 matching lines @@
         if (!readFile(value, tag == FileIndexTag))
             return false;
         creator.pushObjectReference(*value);
         break;
     case FileListTag:
     case FileListIndexTag:
         if (!readFileList(value, tag == FileListIndexTag))
             return false;
         creator.pushObjectReference(*value);
         break;
+    case CompositorProxyTag:
+        if (!readCompositorProxy(value))
+            return false;
+        creator.pushObjectReference(*value);
+        break;
+
     case ImageDataTag:
         if (!readImageData(value))
             return false;
         creator.pushObjectReference(*value);
         break;
 
     case RegExpTag:
         if (!readRegExp(value))
             return false;
         creator.pushObjectReference(*value);
@@ skipping 265 matching lines @@
     RefPtrWillBeRawPtr<ImageData> imageData = ImageData::create(IntSize(width, height));
     DOMUint8ClampedArray* pixelArray = imageData->data();
     ASSERT(pixelArray);
     ASSERT(pixelArray->length() >= pixelDataLength);
     memcpy(pixelArray->data(), m_buffer + m_position, pixelDataLength);
     m_position += pixelDataLength;
     *value = toV8(imageData.release(), m_scriptState->context()->Global(), isolate());
     return true;
 }
 
+bool SerializedScriptValueReader::readCompositorProxy(v8::Local<v8::Value>* value)
+{
+    uint32_t attributes;
+    uint64_t element;
+    if (!doReadUint64(&element))
+        return false;
+    if (!doReadUint32(&attributes))
+        return false;
+
+    CompositorProxy* compositorProxy = CompositorProxy::create(element, attributes);
+    *value = toV8(compositorProxy, m_scriptState->context()->Global(), isolate());
+    return true;
+}
+
 PassRefPtr<DOMArrayBuffer> SerializedScriptValueReader::doReadArrayBuffer()
 {
     uint32_t byteLength;
     if (!doReadUint32(&byteLength))
         return nullptr;
     if (m_position + byteLength > m_length)
         return nullptr;
     const void* bufferStart = m_buffer + m_position;
     m_position += byteLength;
     return DOMArrayBuffer::create(bufferStart, byteLength);
@@ skipping 489 matching lines @@
         return false;
     uint32_t objectReference = m_openCompositeReferenceStack[m_openCompositeReferenceStack.size() - 1];
     m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() - 1);
     if (objectReference >= m_objectPool.size())
         return false;
     *object = m_objectPool[objectReference];
     return true;
 }
 
 } // namespace blink