Implement serialization/deserialization of geometry interfaces

third_party/WebKit/Source/bindings/core/v8/serialization/V8ScriptValueDeserializer.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/V8ScriptValueDeserializer.h"
 
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "core/dom/CompositorProxy.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMSharedArrayBuffer.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/MessagePort.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
 #include "core/frame/ImageBitmap.h"
+#include "core/geometry/DOMMatrix.h"
+#include "core/geometry/DOMMatrixReadOnly.h"
+#include "core/geometry/DOMPoint.h"
+#include "core/geometry/DOMPointInit.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 "core/offscreencanvas/OffscreenCanvas.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/wtf/CheckedNumeric.h"
 #include "platform/wtf/DateMath.h"
 #include "public/platform/WebBlobInfo.h"
 
 namespace blink {
 
@@ skipping 263 matching lines @@
           computed_pixel_length.ValueOrDie() != pixel_length)
         return nullptr;
       ImageData* image_data = ImageData::Create(IntSize(width, height));
       if (!image_data)
         return nullptr;
       DOMUint8ClampedArray* pixel_array = image_data->data();
       DCHECK_EQ(pixel_array->length(), pixel_length);
       memcpy(pixel_array->Data(), pixels, pixel_length);
       return image_data;
     }
+    case kDOMPointTag: {
+      double x = 0, y = 0, z = 0, w = 1;
+      if (!ReadDouble(&x) || !ReadDouble(&y) || !ReadDouble(&z) ||
+          !ReadDouble(&w))
+        return nullptr;
+      DOMPoint* point = DOMPoint::Create(x, y, z, w);
+      if (!point)

[jbroman, 2017/05/15 18:00:30]

nit: These null checks don't really add much (except maybe to suggest that null
is possible?). "return point;" will already return null if point is null (and
there's no other logic being skipped here). Maybe just "return
DOMPoint::Create(...);"? (here and below)

[fserb, 2017/05/15 18:27:28]

yep. done.

+        return nullptr;
+      return point;
+    }
+    case kDOMPointReadOnlyTag: {
+      double x = 0, y = 0, z = 0, w = 1;
+      if (!ReadDouble(&x) || !ReadDouble(&y) || !ReadDouble(&z) ||
+          !ReadDouble(&w))
+        return nullptr;
+      DOMPointReadOnly* point = DOMPointReadOnly::Create(x, y, z, w);
+      if (!point)
+        return nullptr;
+      return point;
+    }
+    case kDOMRectTag: {
+      double x = 0, y = 0, width = 0, height = 0;
+      if (!ReadDouble(&x) || !ReadDouble(&y) || !ReadDouble(&width) ||
+          !ReadDouble(&height))
+        return nullptr;
+      DOMRect* rect = DOMRect::Create(x, y, width, height);
+      if (!rect)
+        return nullptr;
+      return rect;
+    }
+    case kDOMRectReadOnlyTag: {
+      double x = 0, y = 0, width = 0, height = 0;
+      if (!ReadDouble(&x) || !ReadDouble(&y) || !ReadDouble(&width) ||
+          !ReadDouble(&height))
+        return nullptr;
+      DOMRectReadOnly* rect = DOMRectReadOnly::Create(x, y, width, height);
+      if (!rect)
+        return nullptr;
+      return rect;
+    }
+    case kDOMQuadTag: {
+      DOMPointInit pointInits[4];
+      for (DOMPointInit& init : pointInits) {
+        double x = 0, y = 0, z = 0, w = 0;
+        if (!ReadDouble(&x) || !ReadDouble(&y) || !ReadDouble(&z) ||
+            !ReadDouble(&w))
+          return nullptr;
+        init.setX(x);
+        init.setY(y);
+        init.setZ(z);
+        init.setW(w);
+      }
+      DOMQuad* quad = DOMQuad::Create(pointInits[0], pointInits[1],
+                                      pointInits[2], pointInits[3]);
+      if (!quad)
+        return nullptr;
+      return quad;
+    }
+    case kDOMMatrix2DTag: {
+      double values[6];
+      for (double& d : values) {
+        if (!ReadDouble(&d))
+          return nullptr;
+      }
+      DOMMatrix* matrix =
+          DOMMatrix::CreateForSerialization(values, WTF_ARRAY_LENGTH(values));
+      if (!matrix)
+        return nullptr;
+      return matrix;
+    }
+    case kDOMMatrix2DReadOnlyTag: {
+      double values[6];
+      for (double& d : values) {
+        if (!ReadDouble(&d))
+          return nullptr;
+      }
+      DOMMatrixReadOnly* matrix = DOMMatrixReadOnly::CreateForSerialization(
+          values, WTF_ARRAY_LENGTH(values));
+      if (!matrix)
+        return nullptr;
+      return matrix;
+    }
+    case kDOMMatrixTag: {
+      double values[16];
+      for (double& d : values) {
+        if (!ReadDouble(&d))
+          return nullptr;
+      }
+      DOMMatrix* matrix =
+          DOMMatrix::CreateForSerialization(values, WTF_ARRAY_LENGTH(values));
+      if (!matrix)
+        return nullptr;
+      return matrix;
+    }
+    case kDOMMatrixReadOnlyTag: {
+      double values[16];
+      for (double& d : values) {
+        if (!ReadDouble(&d))
+          return nullptr;
+      }
+      DOMMatrixReadOnly* matrix = DOMMatrixReadOnly::CreateForSerialization(
+          values, WTF_ARRAY_LENGTH(values));
+      if (!matrix)
+        return nullptr;
+      return matrix;
+    }
     case kMessagePortTag: {
       uint32_t index = 0;
       if (!ReadUint32(&index) || !transferred_message_ports_ ||
           index >= transferred_message_ports_->size())
         return nullptr;
       return (*transferred_message_ports_)[index].Get();
     }
     case kOffscreenCanvasTransferTag: {
       uint32_t width = 0, height = 0, canvas_id = 0, client_id = 0, sink_id = 0;
       if (!ReadUint32(&width) || !ReadUint32(&height) ||
@@ skipping 104 matching lines @@
                                                uint32_t id) {
   if (id < serialized_script_value_->WasmModules().size()) {
     return v8::WasmCompiledModule::FromTransferrableModule(
         isolate, serialized_script_value_->WasmModules()[id]);
   }
   CHECK(serialized_script_value_->WasmModules().IsEmpty());
   return v8::MaybeLocal<v8::WasmCompiledModule>();
 }
 
 }  // namespace blink