Geometry: Reimplement DOMPoint using V8 extras.

third_party/WebKit/Source/modules/geometry/DOMPoint.js

Index: third_party/WebKit/Source/modules/geometry/DOMPoint.js
diff --git a/third_party/WebKit/Source/modules/geometry/DOMPoint.js b/third_party/WebKit/Source/modules/geometry/DOMPoint.js
new file mode 100644
index 0000000000000000000000000000000000000000..e53da067d8446d788ff683c1fd930a45bcb72091
--- /dev/null
+++ b/third_party/WebKit/Source/modules/geometry/DOMPoint.js
@@ -0,0 +1,110 @@
+// 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.
+
+(function(global, binding, v8) {
+  'use strict';
+
+  const defineProperty = global.Object.defineProperty;
+
+  const xSymbol = v8.createPrivateSymbol('[[x]]');
+  const ySymbol = v8.createPrivateSymbol('[[y]]');
+  const zSymbol = v8.createPrivateSymbol('[[z]]');
+  const wSymbol = v8.createPrivateSymbol('[[w]]');
+
+  class DOMPointReadOnly {
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+      this[xSymbol] = x;
+      this[ySymbol] = y;
+      this[zSymbol] = z;
+      this[wSymbol] = w;
+    }
+
+    get x() {
+      return this[xSymbol];

[domenic, 2016/02/22 18:29:23]

I realized something else that we need to do for spec-compliance :(. We need to
add

if (!(xSymbol in this)) {
  throw new TypeError('Illegal invocation');
}

to all the getters and setters.

Since something has a ySymbol/zSymbol/wSymbol iff it has a xSymbol, you could
extract this into a standalone function:

function ensureDOMPoint(obj) {
  if (!(xSymbol in obj)) {
    throw new TypeError('Illegal invocation');
  }
}

and then just add `ensureDOMPoint(this)` at the top of each getter/setter.

[zino, 2016/02/23 16:13:25]

Thank you for comment first!

But I'm so sorry. I didn't understand your input exactly.
Why do we need to ensure `xSymbol in this`?

In case of updateDOMPoint function, I think it is necessary because ScriptValue
can't be DOMPoint in C++ layer.
On the other hand, in case of getter and setter, it's not exposed to binding
layer.
So, I think that xSymbol(and y, z, w) always exist in DOMPoint internally and JS
author can't remove it from object.

Could you share me the test cases to throw the exception?

+    }
+
+    get y() {
+      return this[ySymbol];
+    }
+
+    get z() {
+      return this[zSymbol];
+    }
+
+    get w() {
+      return this[wSymbol];
+    }
+
+    static fromPoint(init) {
+      return new DOMPointReadOnly(init.x, init.y, init.z, init.w);
+    }
+  }
+
+  class DOMPoint extends DOMPointReadOnly {

[zino, 2016/02/22 09:51:01]

BTW, I didn't found a way to share private symbols in each other files.
So, I wrote DOMPoint and DOMPointReadOnly classes in the same file.
DOMPoint* classes are simple and small but
In case of DOMMatrix* classes, I think it is better to split them into
individual file.

Can we do like this? (But it looks hacky..)
v8.xSymbol = v8.createPrivateSymbol('[[x]]');

Do you have better ideas to split these classes into individual file?

[domenic, 2016/02/22 18:29:23]

That's pretty reasonable, except you should use `binding` instead of `v8` to
store your symbol. `binding` is specifically meant as a place to store things
that are shared between V8 extras and C++, so it is a good place for two V8
extras to work together.

If you do that you might want to namespace them a bit more since `binding` is a
flat namespace. E.g. `const _x = binding.domPointX =
v8.createPrivateSymbol('[[x]]')` and then in your other file you could do `const
{ domPointX: _x, domPointY: _y, ... } = binding`. (You can use `xSymbol` instead
of `_x` too; I just thought that looked a little nicer.)

+    constructor(x = 0, y = 0, z = 0, w = 1) {
+      super(x, y, z, w);
+    }
+
+    get x() {
+      return this[xSymbol];
+    }
+
+    set x(x) {
+      this[xSymbol] = x;

[zino, 2016/02/23 16:13:25]

Is it correct to set NaN if x isn't Number.

e.g.
this[xSymbol] = isNaN(x) ? NaN : x;

+    }
+
+    get y() {
+      return this[ySymbol];
+    }
+
+    set y(y) {
+      this[ySymbol] = y;
+    }
+
+    get z() {
+      return this[zSymbol];
+    }
+
+    set z(z) {
+      this[zSymbol] = z;
+    }
+
+    get w() {
+      return this[wSymbol];
+    }
+
+    set w(w) {
+      this[wSymbol] = w;
+    }
+
+    static fromPoint(init) {
+      return new DOMPoint(init.x, init.y, init.z, init.w);
+    }
+  }
+
+  binding.createDOMPointReadOnly = (x, y, z, w) => new DOMPointReadOnly(x, y, z, w);
+  binding.createDOMPoint = (x, y, z, w) => new DOMPoint(x, y, z, w);
+  binding.updateDOMPoint = function(obj, x, y, z, w) {
+    if (obj instanceof DOMPoint) {

[domenic, 2016/02/22 18:29:23]

A better test (that can't be fooled by author code doing
`someObj[Symbol.hasInstance] = () => true`) is `if (xSymbol in obj)`.

+      obj[xSymbol] = x;
+      obj[ySymbol] = y;
+      obj[zSymbol] = z;
+      obj[wSymbol] = w;
+    }
+  };
+
+  defineProperty(global, 'DOMPointReadOnly', {
+    value: DOMPointReadOnly,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+
+  defineProperty(global, 'DOMPoint', {
+    value: DOMPoint,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+});