MediaPerceptionPrivate API impl and testing.

extensions/browser/api/media_perception_private/conversion_utils.cc

Index: extensions/browser/api/media_perception_private/conversion_utils.cc
diff --git a/extensions/browser/api/media_perception_private/conversion_utils.cc b/extensions/browser/api/media_perception_private/conversion_utils.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a0c4de1f5fb7d39b6bd04b72320c15840851d298
--- /dev/null
+++ b/extensions/browser/api/media_perception_private/conversion_utils.cc
@@ -0,0 +1,243 @@
+// Copyright 2017 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 "extensions/browser/api/media_perception_private/conversion_utils.h"
+
+#include "base/memory/ptr_util.h"
+
+namespace extensions {
+
+namespace {
+
+std::unique_ptr<media_perception::Point> PointProtoToIdl(
+    const mri::Point& point) {
+  std::unique_ptr<media_perception::Point> p_result =
+      base::MakeUnique<media_perception::Point>();
+  if (point.has_x())
+    p_result->x = base::MakeUnique<double>(point.x());
+
+  if (point.has_y())
+    p_result->y = base::MakeUnique<double>(point.y());
+
+  return p_result;
+}
+
+std::unique_ptr<media_perception::BoundingBox> BoundingBoxProtoToIdl(
+    const mri::BoundingBox& bounding_box) {
+  std::unique_ptr<media_perception::BoundingBox> bbox_result =

[tbarzic, 2017/05/17 21:04:41]

rename this to result
or use
bounding_box instead of bbox

This goes for the rest of the file - you should use full words for names

[Luke Sorenson, 2017/05/17 23:07:47]

Done.

+      base::MakeUnique<media_perception::BoundingBox>();
+  if (bounding_box.has_normalized())
+    bbox_result->normalized = base::MakeUnique<bool>(bounding_box.normalized());
+
+  if (bounding_box.has_top_left())
+    bbox_result->top_left = PointProtoToIdl(bounding_box.top_left());
+
+  if (bounding_box.has_bottom_right())
+    bbox_result->bottom_right = PointProtoToIdl(bounding_box.bottom_right());
+
+  return bbox_result;
+}
+
+media_perception::EntityType EntityTypeProtoToIdl(const mri::Entity& entity) {
+  if (entity.has_type()) {
+    switch (entity.type()) {
+      case mri::Entity::FACE:
+        return media_perception::ENTITY_TYPE_FACE;
+      case mri::Entity::PERSON:
+        return media_perception::ENTITY_TYPE_PERSON;
+      case mri::Entity::UNSPECIFIED:
+        return media_perception::ENTITY_TYPE_UNSPECIFIED;
+    }
+    NOTREACHED() << "Unknown entity type: " << entity.type();
+  }
+  return media_perception::ENTITY_TYPE_UNSPECIFIED;
+}
+
+media_perception::Entity EntityProtoToIdl(const mri::Entity& entity) {
+  media_perception::Entity e_result;
+  if (entity.has_id())
+    e_result.id = base::MakeUnique<int>(entity.id());
+
+  e_result.type = EntityTypeProtoToIdl(entity);
+  if (entity.has_confidence())
+    e_result.confidence = base::MakeUnique<double>(entity.confidence());
+
+  if (entity.has_bounding_box())
+    e_result.bounding_box = BoundingBoxProtoToIdl(entity.bounding_box());
+
+  return e_result;
+}
+
+media_perception::FramePerception FramePerceptionProtoToIdl(
+    const mri::FramePerception& frame_perception) {
+  media_perception::FramePerception fp_result;
+  if (frame_perception.has_frame_id())
+    fp_result.frame_id = base::MakeUnique<int>(frame_perception.frame_id());
+
+  if (frame_perception.has_frame_width_in_px()) {
+    fp_result.frame_width_in_px =
+        base::MakeUnique<int>(frame_perception.frame_width_in_px());
+  }
+  if (frame_perception.has_frame_height_in_px()) {
+    fp_result.frame_height_in_px =
+        base::MakeUnique<int>(frame_perception.frame_height_in_px());
+  }
+  if (frame_perception.has_timestamp()) {
+    fp_result.timestamp =
+        base::MakeUnique<double>(frame_perception.timestamp());
+  }
+  if (frame_perception.entity_size() > 0) {
+    fp_result.entities =
+        base::MakeUnique<std::vector<media_perception::Entity>>();

[tbarzic, 2017/05/17 21:04:41]

I'd consider making the arrays required in the idls, unless the distinction
between null and empty arrays is important to the app 

[Luke Sorenson, 2017/05/17 23:07:47]

The distinction is important. It's the difference between no detected entities
and the face detection module not having run at all.

+    for (const auto& entity : frame_perception.entity()) {

[tbarzic, 2017/05/17 21:04:41]

nit: no {} here

[Luke Sorenson, 2017/05/17 23:07:47]

Done.

+      fp_result.entities->emplace_back(EntityProtoToIdl(entity));
+    }
+  }
+  return fp_result;
+}
+
+media_perception::ImageFormat ImageFormatProtoToIdl(
+    const mri::ImageFrame& image_frame) {
+  if (image_frame.has_format()) {
+    switch (image_frame.format()) {
+      case mri::ImageFrame::RGB:
+        return media_perception::IMAGE_FORMAT_RGB;
+      case mri::ImageFrame::PNG:
+        return media_perception::IMAGE_FORMAT_PNG;
+      case mri::ImageFrame::JPEG:
+        return media_perception::IMAGE_FORMAT_JPEG;
+      case mri::ImageFrame::FORMAT_UNSPECIFIED:
+        return media_perception::IMAGE_FORMAT_UNSPECIFIED;
+    }
+    NOTREACHED() << "Unknown image format: " << image_frame.format();
+  }
+  return media_perception::IMAGE_FORMAT_UNSPECIFIED;
+}
+
+media_perception::ImageFrame ImageFrameProtoToIdl(
+    const mri::ImageFrame& image_frame) {
+  media_perception::ImageFrame if_result;
+  if (image_frame.has_width())
+    if_result.width = base::MakeUnique<int>(image_frame.width());
+
+  if (image_frame.has_height())
+    if_result.height = base::MakeUnique<int>(image_frame.height());
+
+  if (image_frame.has_data_length())
+    if_result.data_length = base::MakeUnique<int>(image_frame.data_length());
+
+  if (image_frame.has_pixel_data()) {
+    if_result.frame = base::MakeUnique<std::vector<char>>(
+        image_frame.pixel_data().begin(), image_frame.pixel_data().end());
+  }
+
+  if_result.format = ImageFormatProtoToIdl(image_frame);
+  return if_result;
+}
+
+media_perception::PerceptionSample PerceptionSampleProtoToIdl(
+    const mri::PerceptionSample& perception_sample) {
+  media_perception::PerceptionSample ps_result;
+  if (perception_sample.has_frame_perception()) {
+    ps_result.frame_perception =
+        base::MakeUnique<media_perception::FramePerception>(
+            FramePerceptionProtoToIdl(perception_sample.frame_perception()));
+  }
+  if (perception_sample.has_image_frame()) {
+    ps_result.image_frame = base::MakeUnique<media_perception::ImageFrame>(

[tbarzic, 2017/05/17 21:04:41]

I don't think you need to MakeUnique here = ImageFrameProtoToIdl already returns
a unique_ptr

[Luke Sorenson, 2017/05/17 23:07:47]

I need it because ImageFrameProtoToIdl returns an ImageFrame object not a unique
ptr.

+        ImageFrameProtoToIdl(perception_sample.image_frame()));
+  }
+  return ps_result;
+}
+
+}  //  namespace
+
+media_perception::State StateProtoToIdl(const mri::State& state) {
+  media_perception::State s_result;
+  if (state.has_status()) {
+    switch (state.status()) {
+      case mri::State::UNINITIALIZED:
+        s_result.status = media_perception::STATUS_UNINITIALIZED;
+        break;
+      case mri::State::STARTED:
+        s_result.status = media_perception::STATUS_STARTED;
+        break;
+      case mri::State::RUNNING:
+        s_result.status = media_perception::STATUS_RUNNING;
+        break;
+      case mri::State::SUSPENDED:
+        s_result.status = media_perception::STATUS_SUSPENDED;
+        break;
+      case mri::State::STATUS_UNSPECIFIED:
+      default:

[tbarzic, 2017/05/17 21:04:41]

no default here.
also, you should convert the UNSPECIFIED state to something here.

[Luke Sorenson, 2017/05/17 23:07:47]

Removed default. Not sure that I should be converting UNSPECIFIED to something
else?

+        NOTREACHED() << "Status not set.";
+        break;
+    }
+  }
+  if (state.has_device_context()) {
+    s_result.device_context =
+        base::MakeUnique<std::string>(state.device_context());
+  }
+  return s_result;
+}
+
+mri::State StateIdlToProto(const media_perception::State& state) {
+  mri::State s_result;
+  switch (state.status) {
+    case media_perception::STATUS_UNINITIALIZED:
+      s_result.set_status(mri::State::UNINITIALIZED);
+      break;
+    case media_perception::STATUS_STARTED:
+      s_result.set_status(mri::State::STARTED);
+      break;
+    case media_perception::STATUS_RUNNING:
+      s_result.set_status(mri::State::RUNNING);
+      break;
+    case media_perception::STATUS_SUSPENDED:
+      s_result.set_status(mri::State::SUSPENDED);
+      break;
+    default:

[tbarzic, 2017/05/17 21:04:41]

no default

[Luke Sorenson, 2017/05/17 23:07:47]

Are you saying to remove the NOTREACHED() as well?

+      NOTREACHED() << "Status not set.";
+      break;
+  }
+  if (state.device_context)
+    s_result.set_device_context(*state.device_context);
+
+  return s_result;
+}
+
+media_perception::MediaPerception MediaPerceptionProtoToIdl(
+    const mri::MediaPerception& media_perception) {
+  media_perception::MediaPerception mp_result;
+  if (media_perception.has_timestamp()) {
+    mp_result.timestamp =
+        base::MakeUnique<double>(media_perception.timestamp());
+  }
+
+  if (media_perception.frame_perception_size() > 0) {
+    mp_result.frame_perceptions =
+        base::MakeUnique<std::vector<media_perception::FramePerception>>();
+    for (const auto& frame_perception : media_perception.frame_perception()) {
+      mp_result.frame_perceptions->emplace_back(
+          FramePerceptionProtoToIdl(frame_perception));
+    }
+  }
+  return mp_result;
+}
+
+media_perception::Diagnostics DiagnosticsProtoToIdl(
+    const mri::Diagnostics& diagnostics) {
+  media_perception::Diagnostics d_result;
+  if (diagnostics.perception_sample_size() > 0) {
+    d_result.perception_samples =
+        base::MakeUnique<std::vector<media_perception::PerceptionSample>>();
+    for (const auto& perception_sample : diagnostics.perception_sample()) {
+      d_result.perception_samples->emplace_back(
+          PerceptionSampleProtoToIdl(perception_sample));
+    }
+  }
+  return d_result;
+}
+
+}  // namespace extensions