Add Typemapping for WebXR mojom types to Blink

This is the first step to convert the types in the vr_service.mojom to
common gfx.mojom geometry types.  By adding typemaps from the gfx.mojom
geometry types on the blink side, we can have cleaner and consistent
code across both sides of the mojom pipe.

Bug: 977008
Change-Id: I1eafdc938be9d5dc7e67ecd5c964d07a90bc6d29
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1668569Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Bill Orr <billorr@chromium.org>
Commit-Queue: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#672665}

third_party/blink/renderer/modules/xr/xr_bounded_reference_space.cc

@@ -54,7 +54,7 @@ void XRBoundedReferenceSpace::EnsureUpdated() {
 
       for (const auto& bound : *(display_info->stageParameters->bounds)) {
         FloatPoint3D p =
-            bounds_transform.MapPoint(FloatPoint3D(bound->x, 0.0, bound->z));
+            bounds_transform.MapPoint(FloatPoint3D(bound.x, 0.0, bound.z));
         bounds_geometry_.push_back(
             DOMPointReadOnly::Create(p.X(), p.Y(), p.Z(), 1.0));
       }

third_party/blink/renderer/modules/xr/xr_input_source.cc

@@ -16,10 +16,9 @@ namespace blink {
 
 namespace {
 std::unique_ptr<TransformationMatrix> TryGetTransformationMatrix(
-    const gfx::mojom::blink::TransformPtr& transform) {
-  if (transform && transform->matrix.has_value()) {
-    return std::make_unique<TransformationMatrix>(
-        WTFFloatVectorToTransformationMatrix(transform->matrix.value()));
+    const base::Optional<gfx::Transform>& transform) {
+  if (transform) {
+    return std::make_unique<TransformationMatrix>(transform->matrix());
   }
 
   return nullptr;

third_party/blink/renderer/modules/xr/xr_session.cc

@@ -372,15 +372,11 @@ ScriptPromise XRSession::requestHitTest(ScriptState* script_state,
 
   device::mojom::blink::XRRayPtr ray_mojo = device::mojom::blink::XRRay::New();
 
-  ray_mojo->origin = gfx::mojom::blink::Point3F::New();
-  ray_mojo->origin->x = ray->origin()->x();
-  ray_mojo->origin->y = ray->origin()->y();
-  ray_mojo->origin->z = ray->origin()->z();
-
-  ray_mojo->direction = gfx::mojom::blink::Vector3dF::New();
-  ray_mojo->direction->x = ray->direction()->x();
-  ray_mojo->direction->y = ray->direction()->y();
-  ray_mojo->direction->z = ray->direction()->z();
+  ray_mojo->origin = WebFloatPoint3D(ray->origin()->x(), ray->origin()->y(),
+                                     ray->origin()->z());
+
+  ray_mojo->direction = {ray->direction()->x(), ray->direction()->y(),
+                         ray->direction()->z()};
 
   auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
   ScriptPromise promise = resolver->Promise();

third_party/blink/renderer/platform/mojo/blink_typemaps.gni

@@ -3,6 +3,7 @@
 # found in the LICENSE file.
 
 typemaps = [
+  "//ui//gfx//mojo//transform.typemap",
   "//third_party/blink/renderer/core/messaging/blink_cloneable_message.typemap",
   "//third_party/blink/renderer/core/messaging/blink_transferable_message.typemap",
   "//third_party/blink/renderer/modules/indexeddb/indexed_db_blink.typemap",

third_party/blink/renderer/platform/mojo/geometry.typemap

@@ -4,8 +4,11 @@
 
 mojom = "//ui/gfx/geometry/mojo/geometry.mojom"
 public_headers = [
+  "//ui/gfx/geometry/quaternion.h",
+  "//ui/gfx/geometry/vector3d_f.h",
   "//third_party/blink/public/platform/web_float_rect.h",
   "//third_party/blink/public/platform/web_float_point.h",
+  "//third_party/blink/public/platform/web_float_point_3d.h",
   "//third_party/blink/public/platform/web_point.h",
   "//third_party/blink/public/platform/web_rect.h",
   "//third_party/blink/public/platform/web_size.h",
@@ -29,7 +32,10 @@ public_deps = [
 type_mappings = [
   "gfx.mojom.Point=::blink::WebPoint",
   "gfx.mojom.PointF=::blink::WebFloatPoint",
+  "gfx.mojom.Point3F=::blink::WebFloatPoint3D",
+  "gfx.mojom.Quaternion=gfx::Quaternion",
   "gfx.mojom.RectF=::blink::WebFloatRect",
   "gfx.mojom.Rect=::blink::WebRect",
   "gfx.mojom.Size=::blink::WebSize",
+  "gfx.mojom.Vector3dF=gfx::Vector3dF",
 ]

third_party/blink/renderer/platform/mojo/geometry_struct_traits.cc

@@ -50,6 +50,15 @@ bool StructTraits<gfx::mojom::PointFDataView, ::blink::WebFloatPoint>::Read(
   return true;
 }
 
+bool StructTraits<gfx::mojom::Point3FDataView, ::blink::WebFloatPoint3D>::Read(
+    gfx::mojom::Point3FDataView data,
+    ::blink::WebFloatPoint3D* out) {
+  out->x = data.x();
+  out->y = data.y();
+  out->z = data.z();
+  return true;
+}
+
 // static
 bool StructTraits<gfx::mojom::SizeDataView, ::blink::WebSize>::Read(
     gfx::mojom::SizeDataView data,

third_party/blink/renderer/platform/mojo/geometry_struct_traits.h

@@ -6,6 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_MOJO_GEOMETRY_STRUCT_TRAITS_H_
 
 #include "third_party/blink/public/platform/web_float_point.h"
+#include "third_party/blink/public/platform/web_float_point_3d.h"
 #include "third_party/blink/public/platform/web_float_rect.h"
 #include "third_party/blink/public/platform/web_point.h"
 #include "third_party/blink/public/platform/web_rect.h"
@@ -28,6 +29,15 @@ struct StructTraits<gfx::mojom::PointFDataView, ::blink::WebFloatPoint> {
   static bool Read(gfx::mojom::PointFDataView, ::blink::WebFloatPoint* out);
 };
 
+template <>
+struct StructTraits<gfx::mojom::Point3FDataView, ::blink::WebFloatPoint3D> {
+  static float x(const gfx::Point3F& p) { return p.x(); }
+  static float y(const gfx::Point3F& p) { return p.y(); }
+  static float z(const gfx::Point3F& p) { return p.z(); }
+  static bool Read(gfx::mojom::Point3FDataView data,
+                   ::blink::WebFloatPoint3D* out);
+};
+
 template <>
 struct StructTraits<gfx::mojom::RectFDataView, ::blink::WebFloatRect> {
   static float x(const ::blink::WebFloatRect& rect) { return rect.x; }

third_party/blink/renderer/platform/mojo/geometry_struct_traits_test.cc

@@ -38,10 +38,9 @@ class GeometryStructTraitsTest
     std::move(callback).Run(p);
   }
 
-  void EchoPoint3F(::gfx::mojom::blink::Point3FPtr p,
+  void EchoPoint3F(const WebFloatPoint3D& p,
                    EchoPoint3FCallback callback) override {
-    // The type map is not specified.
-    NOTREACHED();
+    std::move(callback).Run(p);
   }
 
   void EchoSize(const WebSize& s, EchoSizeCallback callback) override {
@@ -84,16 +83,14 @@ class GeometryStructTraitsTest
     NOTREACHED();
   }
 
-  void EchoVector3dF(gfx::mojom::blink::Vector3dFPtr,
-                     EchoVector3dFCallback) override {
-    // The type map is not specified.
-    NOTREACHED();
+  void EchoVector3dF(const gfx::Vector3dF& v,
+                     EchoVector3dFCallback callback) override {
+    std::move(callback).Run(v);
   }
 
-  void EchoQuaternion(gfx::mojom::blink::QuaternionPtr,
-                      EchoQuaternionCallback) override {
-    // The type map is not specified.
-    NOTREACHED();
+  void EchoQuaternion(const gfx::Quaternion& q,
+                      EchoQuaternionCallback callback) override {
+    std::move(callback).Run(q);
   }
 
   mojo::BindingSet<gfx::mojom::blink::GeometryTraitsTestService>
@@ -136,6 +133,17 @@ TEST_F(GeometryStructTraitsTest, PointF) {
   EXPECT_EQ(input, output);
 }
 
+TEST_F(GeometryStructTraitsTest, Point3D) {
+  const float kX = 1.234;
+  const float kY = 5.678;
+  const float kZ = 9.098;
+  WebFloatPoint3D input(kX, kY, kZ);
+  gfx::mojom::blink::GeometryTraitsTestServicePtr proxy = GetTraitsTestProxy();
+  WebFloatPoint3D output;
+  proxy->EchoPoint3F(input, &output);
+  EXPECT_EQ(input, output);
+}
+
 TEST_F(GeometryStructTraitsTest, Rect) {
   const float kX = 1;
   const float kY = 2;

third_party/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py

@@ -220,6 +220,7 @@ _CONFIG = [
             # Chromium geometry types.
             'gfx::Point',
             'gfx::Point3F',
+            'gfx::Quaternion',
             'gfx::Rect',
             'gfx::RectF',
             'gfx::RRectF',