Implement serialization/deserialization of geometry interfaces

third_party/WebKit/Source/bindings/core/v8/serialization/V8ScriptValueSerializer.cpp

 // Copyright 2016 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 "bindings/core/v8/serialization/V8ScriptValueSerializer.h"
 
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8CompositorProxy.h"
+#include "bindings/core/v8/V8DOMMatrix.h"
+#include "bindings/core/v8/V8DOMMatrixReadOnly.h"
+#include "bindings/core/v8/V8DOMPoint.h"
+#include "bindings/core/v8/V8DOMPointReadOnly.h"
+#include "bindings/core/v8/V8DOMQuad.h"
+#include "bindings/core/v8/V8DOMRect.h"
+#include "bindings/core/v8/V8DOMRectReadOnly.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
 #include "bindings/core/v8/V8ImageBitmap.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
 #include "bindings/core/v8/V8OffscreenCanvas.h"
 #include "bindings/core/v8/V8SharedArrayBuffer.h"
 #include "bindings/core/v8/V8ThrowDOMException.h"
 #include "core/dom/DOMArrayBufferBase.h"
+#include "core/geometry/DOMMatrix.h"
+#include "core/geometry/DOMMatrixReadOnly.h"
+#include "core/geometry/DOMPoint.h"
+#include "core/geometry/DOMPointReadOnly.h"
+#include "core/geometry/DOMQuad.h"
+#include "core/geometry/DOMRect.h"
+#include "core/geometry/DOMRectReadOnly.h"
 #include "core/html/ImageData.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/wtf/AutoReset.h"
 #include "platform/wtf/DateMath.h"
 #include "platform/wtf/allocator/Partitions.h"
 #include "platform/wtf/text/StringUTF8Adaptor.h"
 #include "public/platform/WebBlobInfo.h"
 
 namespace blink {
 
@@ skipping 232 matching lines @@
   if (wrapper_type_info == &V8ImageData::wrapperTypeInfo) {
     ImageData* image_data = wrappable->ToImpl<ImageData>();
     DOMUint8ClampedArray* pixels = image_data->data();
     WriteTag(kImageDataTag);
     WriteUint32(image_data->width());
     WriteUint32(image_data->height());
     WriteUint32(pixels->length());
     WriteRawBytes(pixels->Data(), pixels->length());
     return true;
   }
+  if (wrapper_type_info == &V8DOMPoint::wrapperTypeInfo) {
+    DOMPoint* point = wrappable->ToImpl<DOMPoint>();
+    WriteTag(kDOMPointTag);
+    WriteDouble(point->x());
+    WriteDouble(point->y());
+    WriteDouble(point->z());
+    WriteDouble(point->w());
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMPointReadOnly::wrapperTypeInfo) {
+    DOMPointReadOnly* point = wrappable->ToImpl<DOMPointReadOnly>();
+    WriteTag(kDOMPointReadOnlyTag);
+    WriteDouble(point->x());
+    WriteDouble(point->y());
+    WriteDouble(point->z());
+    WriteDouble(point->w());
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMRect::wrapperTypeInfo) {
+    DOMRect* rect = wrappable->ToImpl<DOMRect>();
+    WriteTag(kDOMRectTag);
+    WriteDouble(rect->x());
+    WriteDouble(rect->y());
+    WriteDouble(rect->width());
+    WriteDouble(rect->height());
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMRectReadOnly::wrapperTypeInfo) {
+    DOMRectReadOnly* rect = wrappable->ToImpl<DOMRectReadOnly>();
+    WriteTag(kDOMRectReadOnlyTag);
+    WriteDouble(rect->x());
+    WriteDouble(rect->y());
+    WriteDouble(rect->width());
+    WriteDouble(rect->height());
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMQuad::wrapperTypeInfo) {
+    DOMQuad* quad = wrappable->ToImpl<DOMQuad>();
+    WriteTag(kDOMQuadTag);
+    WriteDouble(quad->p1()->x());

[jbroman, 2017/05/15 17:02:55]

nit: or, this could be:

for (const DOMPoint* point : {quad->p1(), quad->p2(), quad->p3(), quad->p4()}) {
  WriteDouble(point->x());
  WriteDouble(point->y());
  WriteDouble(point->z());
  WriteDouble(point->w());
}

At the moment I have to scan this to make sure it's correct, which is a little
tedious. The compiler might well unroll it again anyhow.

[fserb, 2017/05/15 17:52:17]

much better. ;)

+    WriteDouble(quad->p1()->y());
+    WriteDouble(quad->p1()->z());
+    WriteDouble(quad->p1()->w());
+    WriteDouble(quad->p2()->x());
+    WriteDouble(quad->p2()->y());
+    WriteDouble(quad->p2()->z());
+    WriteDouble(quad->p2()->w());
+    WriteDouble(quad->p3()->x());
+    WriteDouble(quad->p3()->y());
+    WriteDouble(quad->p3()->z());
+    WriteDouble(quad->p3()->w());
+    WriteDouble(quad->p4()->x());
+    WriteDouble(quad->p4()->y());
+    WriteDouble(quad->p4()->z());
+    WriteDouble(quad->p4()->w());
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMMatrix::wrapperTypeInfo) {
+    DOMMatrix* matrix = wrappable->ToImpl<DOMMatrix>();
+    if (matrix->is2D()) {
+      WriteTag(kDOMMatrix2DTag);
+      WriteDouble(matrix->a());
+      WriteDouble(matrix->b());
+      WriteDouble(matrix->c());
+      WriteDouble(matrix->d());
+      WriteDouble(matrix->e());
+      WriteDouble(matrix->f());
+    } else {
+      WriteTag(kDOMMatrixTag);
+      WriteDouble(matrix->m11());
+      WriteDouble(matrix->m12());
+      WriteDouble(matrix->m13());
+      WriteDouble(matrix->m14());
+      WriteDouble(matrix->m21());
+      WriteDouble(matrix->m22());
+      WriteDouble(matrix->m23());
+      WriteDouble(matrix->m24());
+      WriteDouble(matrix->m31());
+      WriteDouble(matrix->m32());
+      WriteDouble(matrix->m33());
+      WriteDouble(matrix->m34());
+      WriteDouble(matrix->m41());
+      WriteDouble(matrix->m42());
+      WriteDouble(matrix->m43());
+      WriteDouble(matrix->m44());
+    }
+    return true;
+  }
+  if (wrapper_type_info == &V8DOMMatrixReadOnly::wrapperTypeInfo) {
+    DOMMatrixReadOnly* matrix = wrappable->ToImpl<DOMMatrixReadOnly>();
+    if (matrix->is2D()) {
+      WriteTag(kDOMMatrix2DReadOnlyTag);
+      WriteDouble(matrix->a());
+      WriteDouble(matrix->b());
+      WriteDouble(matrix->c());
+      WriteDouble(matrix->d());
+      WriteDouble(matrix->e());
+      WriteDouble(matrix->f());
+    } else {
+      WriteTag(kDOMMatrixReadOnlyTag);
+      WriteDouble(matrix->m11());
+      WriteDouble(matrix->m12());
+      WriteDouble(matrix->m13());
+      WriteDouble(matrix->m14());
+      WriteDouble(matrix->m21());
+      WriteDouble(matrix->m22());
+      WriteDouble(matrix->m23());
+      WriteDouble(matrix->m24());
+      WriteDouble(matrix->m31());
+      WriteDouble(matrix->m32());
+      WriteDouble(matrix->m33());
+      WriteDouble(matrix->m34());
+      WriteDouble(matrix->m41());
+      WriteDouble(matrix->m42());
+      WriteDouble(matrix->m43());
+      WriteDouble(matrix->m44());
+    }
+    return true;
+  }
   if (wrapper_type_info == &V8MessagePort::wrapperTypeInfo) {
     MessagePort* message_port = wrappable->ToImpl<MessagePort>();
     size_t index = kNotFound;
     if (transferables_)
       index = transferables_->message_ports.Find(message_port);
     if (index == kNotFound) {
       exception_state.ThrowDOMException(
           kDataCloneError,
           "A MessagePort could not be cloned because it was not transferred.");
       return false;
@@ skipping 184 matching lines @@
   *actual_size = WTF::Partitions::BufferActualSize(size);
   return WTF::Partitions::BufferRealloc(old_buffer, *actual_size,
                                         "SerializedScriptValue buffer");
 }
 
 void V8ScriptValueSerializer::FreeBufferMemory(void* buffer) {
   return WTF::Partitions::BufferFree(buffer);
 }
 
 }  // namespace blink