1 files changed, 204 insertions, 0 deletions
diff --git a/chromium/third_party/blink/renderer/modules/handwriting/handwriting_type_converters.cc b/chromium/third_party/blink/renderer/modules/handwriting/handwriting_type_converters.cc
new file mode 100644
index 00000000000..71771bcecd7
--- /dev/null
+++ b/chromium/third_party/blink/renderer/modules/handwriting/handwriting_type_converters.cc
@@ -0,0 +1,204 @@
+// Copyright 2021 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 "third_party/blink/renderer/modules/handwriting/handwriting_type_converters.h"
+
+#include "third_party/blink/public/mojom/handwriting/handwriting.mojom-blink.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_drawing_segment.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_feature_query.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_feature_query_result.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_hints.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_point.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_prediction.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_segment.h"
+#include "third_party/blink/renderer/bindings/modules/v8/v8_handwriting_stroke.h"
+#include "third_party/blink/renderer/modules/modules_export.h"
+
+namespace mojo {
+
+using handwriting::mojom::blink::HandwritingDrawingSegmentPtr;
+using handwriting::mojom::blink::HandwritingFeatureQueryPtr;
+using handwriting::mojom::blink::HandwritingFeatureQueryResultPtr;
+using handwriting::mojom::blink::HandwritingFeatureStatus;
+using handwriting::mojom::blink::HandwritingHintsPtr;
+using handwriting::mojom::blink::HandwritingPointPtr;
+using handwriting::mojom::blink::HandwritingPredictionPtr;
+using handwriting::mojom::blink::HandwritingSegmentPtr;
+using handwriting::mojom::blink::HandwritingStrokePtr;
+
+// Converters from IDL to Mojo.
+
+// static
+HandwritingPointPtr
+TypeConverter<HandwritingPointPtr, blink::HandwritingPoint*>::Convert(
+    const blink::HandwritingPoint* input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto output = handwriting::mojom::blink::HandwritingPoint::New();
+  output->location = gfx::PointF(input->x(), input->y());
+  output->t = base::TimeDelta::FromMilliseconds(input->t());
+  return output;
+}
+
+// static
+HandwritingStrokePtr
+TypeConverter<HandwritingStrokePtr, blink::HandwritingStroke*>::Convert(
+    const blink::HandwritingStroke* input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto output = handwriting::mojom::blink::HandwritingStroke::New();
+  for (const auto& point : input->getPoints()) {
+    output->points.push_back(mojo::ConvertTo<HandwritingPointPtr>(point.Get()));
+  }
+  return output;
+}
+
+// static
+HandwritingHintsPtr
+TypeConverter<HandwritingHintsPtr, blink::HandwritingHints*>::Convert(
+    const blink::HandwritingHints* input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto output = handwriting::mojom::blink::HandwritingHints::New();
+  output->recognition_type = input->recognitionType();
+  output->input_type = input->inputType();
+  output->text_context = input->textContext();
+  output->alternatives = input->alternatives();
+  return output;
+}
+
+// static
+HandwritingFeatureQueryPtr
+TypeConverter<HandwritingFeatureQueryPtr, blink::HandwritingFeatureQuery*>::
+    Convert(const blink::HandwritingFeatureQuery* input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto output = handwriting::mojom::blink::HandwritingFeatureQuery::New();
+  if (input->hasLanguages()) {
+    for (const auto& lang : input->languages()) {
+      output->languages.push_back(lang);
+    }
+  }
+  output->alternatives = input->hasAlternatives();
+  output->segmentation_result = input->hasSegmentationResult();
+
+  return output;
+}
+
+// Converters from Mojo to IDL.
+
+// static
+blink::HandwritingPoint*
+TypeConverter<blink::HandwritingPoint*, HandwritingPointPtr>::Convert(
+    const HandwritingPointPtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingPoint::Create();
+  output->setX(input->location.x());
+  output->setY(input->location.y());
+  output->setT(input->t.InMilliseconds());
+  return output;
+}
+
+// static
+blink::HandwritingStroke*
+TypeConverter<blink::HandwritingStroke*, HandwritingStrokePtr>::Convert(
+    const HandwritingStrokePtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingStroke::Create();
+  for (const auto& point : input->points) {
+    output->addPoint(point.To<blink::HandwritingPoint*>());
+  }
+  return output;
+}
+
+// static
+blink::HandwritingFeatureQueryResult*
+TypeConverter<blink::HandwritingFeatureQueryResult*,
+              HandwritingFeatureQueryResultPtr>::
+    Convert(const HandwritingFeatureQueryResultPtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingFeatureQueryResult::Create();
+
+#define HANDWRITING_SET_FEATURE_QUERY_RESULT(feature, setter)        \
+  if (input->feature != HandwritingFeatureStatus::kNotQueried) {     \
+    if (input->feature == HandwritingFeatureStatus::kNotSupported) { \
+      output->setter(false);                                         \
+    } else {                                                         \
+      output->setter(true);                                          \
+    }                                                                \
+  }
+
+  HANDWRITING_SET_FEATURE_QUERY_RESULT(languages, setLanguages);
+  HANDWRITING_SET_FEATURE_QUERY_RESULT(alternatives, setAlternatives);
+  HANDWRITING_SET_FEATURE_QUERY_RESULT(segmentation_result,
+                                       setSegmentationResult);
+#undef HANDWRITING_SET_FEATURE_QUERY_RESULT
+
+  return output;
+}
+
+// static
+blink::HandwritingDrawingSegment*
+TypeConverter<blink::HandwritingDrawingSegment*, HandwritingDrawingSegmentPtr>::
+    Convert(const HandwritingDrawingSegmentPtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingDrawingSegment::Create();
+  output->setStrokeIndex(input->stroke_index);
+  output->setBeginPointIndex(input->begin_point_index);
+  output->setEndPointIndex(input->end_point_index);
+  return output;
+}
+
+// static
+blink::HandwritingSegment*
+TypeConverter<blink::HandwritingSegment*,
+              handwriting::mojom::blink::HandwritingSegmentPtr>::
+    Convert(const handwriting::mojom::blink::HandwritingSegmentPtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingSegment::Create();
+  output->setGrapheme(input->grapheme);
+  output->setBeginIndex(input->begin_index);
+  output->setEndIndex(input->end_index);
+  blink::HeapVector<blink::Member<blink::HandwritingDrawingSegment>>
+      drawing_segments;
+  for (const auto& drw_seg : input->drawing_segments) {
+    drawing_segments.push_back(drw_seg.To<blink::HandwritingDrawingSegment*>());
+  }
+  output->setDrawingSegments(std::move(drawing_segments));
+  return output;
+}
+
+// static
+blink::HandwritingPrediction*
+TypeConverter<blink::HandwritingPrediction*,
+              handwriting::mojom::blink::HandwritingPredictionPtr>::
+    Convert(const handwriting::mojom::blink::HandwritingPredictionPtr& input) {
+  if (!input) {
+    return nullptr;
+  }
+  auto* output = blink::HandwritingPrediction::Create();
+  output->setText(input->text);
+  blink::HeapVector<blink::Member<blink::HandwritingSegment>> segments;
+  for (const auto& seg : input->segmentation_result) {
+    segments.push_back(seg.To<blink::HandwritingSegment*>());
+  }
+  output->setSegmentationResult(std::move(segments));
+  return output;
+}
+
+}  // namespace mojo