Revert of 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
deleted file mode 100644
index ea303fc53367c364853836c8f9d03b323114bfec..0000000000000000000000000000000000000000
--- a/extensions/browser/api/media_perception_private/conversion_utils.cc
+++ /dev/null
@@ -1,248 +0,0 @@
-// 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 api {
-namespace media_perception_private {
-
-namespace {
-
-std::unique_ptr<Point> PointProtoToIdl(const mri::Point& point) {
-  std::unique_ptr<Point> point_result = base::MakeUnique<Point>();
-  if (point.has_x())
-    point_result->x = base::MakeUnique<double>(point.x());
-
-  if (point.has_y())
-    point_result->y = base::MakeUnique<double>(point.y());
-
-  return point_result;
-}
-
-std::unique_ptr<BoundingBox> BoundingBoxProtoToIdl(
-    const mri::BoundingBox& bounding_box) {
-  std::unique_ptr<BoundingBox> bounding_box_result =
-      base::MakeUnique<BoundingBox>();
-  if (bounding_box.has_normalized()) {
-    bounding_box_result->normalized =
-        base::MakeUnique<bool>(bounding_box.normalized());
-  }
-
-  if (bounding_box.has_top_left())
-    bounding_box_result->top_left = PointProtoToIdl(bounding_box.top_left());
-
-  if (bounding_box.has_bottom_right()) {
-    bounding_box_result->bottom_right =
-        PointProtoToIdl(bounding_box.bottom_right());
-  }
-
-  return bounding_box_result;
-}
-
-EntityType EntityTypeProtoToIdl(const mri::Entity& entity) {
-  if (entity.has_type()) {
-    switch (entity.type()) {
-      case mri::Entity::FACE:
-        return ENTITY_TYPE_FACE;
-      case mri::Entity::PERSON:
-        return ENTITY_TYPE_PERSON;
-      case mri::Entity::UNSPECIFIED:
-        return ENTITY_TYPE_UNSPECIFIED;
-    }
-    NOTREACHED() << "Unknown entity type: " << entity.type();
-  }
-  return ENTITY_TYPE_UNSPECIFIED;
-}
-
-Entity EntityProtoToIdl(const mri::Entity& entity) {
-  Entity entity_result;
-  if (entity.has_id())
-    entity_result.id = base::MakeUnique<int>(entity.id());
-
-  entity_result.type = EntityTypeProtoToIdl(entity);
-  if (entity.has_confidence())
-    entity_result.confidence = base::MakeUnique<double>(entity.confidence());
-
-  if (entity.has_bounding_box())
-    entity_result.bounding_box = BoundingBoxProtoToIdl(entity.bounding_box());
-
-  return entity_result;
-}
-
-FramePerception FramePerceptionProtoToIdl(
-    const mri::FramePerception& frame_perception) {
-  FramePerception frame_perception_result;
-  if (frame_perception.has_frame_id()) {
-    frame_perception_result.frame_id =
-        base::MakeUnique<int>(frame_perception.frame_id());
-  }
-  if (frame_perception.has_frame_width_in_px()) {
-    frame_perception_result.frame_width_in_px =
-        base::MakeUnique<int>(frame_perception.frame_width_in_px());
-  }
-  if (frame_perception.has_frame_height_in_px()) {
-    frame_perception_result.frame_height_in_px =
-        base::MakeUnique<int>(frame_perception.frame_height_in_px());
-  }
-  if (frame_perception.has_timestamp()) {
-    frame_perception_result.timestamp =
-        base::MakeUnique<double>(frame_perception.timestamp());
-  }
-  if (frame_perception.entity_size() > 0) {
-    frame_perception_result.entities = base::MakeUnique<std::vector<Entity>>();
-    for (const auto& entity : frame_perception.entity())
-      frame_perception_result.entities->emplace_back(EntityProtoToIdl(entity));
-  }
-  return frame_perception_result;
-}
-
-ImageFormat ImageFormatProtoToIdl(const mri::ImageFrame& image_frame) {
-  if (image_frame.has_format()) {
-    switch (image_frame.format()) {
-      case mri::ImageFrame::RGB:
-        return IMAGE_FORMAT_RAW;
-      case mri::ImageFrame::PNG:
-        return IMAGE_FORMAT_PNG;
-      case mri::ImageFrame::JPEG:
-        return IMAGE_FORMAT_JPEG;
-      case mri::ImageFrame::FORMAT_UNSPECIFIED:
-        return IMAGE_FORMAT_NONE;
-    }
-    NOTREACHED() << "Unknown image format: " << image_frame.format();
-  }
-  return IMAGE_FORMAT_NONE;
-}
-
-ImageFrame ImageFrameProtoToIdl(const mri::ImageFrame& image_frame) {
-  ImageFrame image_frame_result;
-  if (image_frame.has_width())
-    image_frame_result.width = base::MakeUnique<int>(image_frame.width());
-
-  if (image_frame.has_height())
-    image_frame_result.height = base::MakeUnique<int>(image_frame.height());
-
-  if (image_frame.has_data_length()) {
-    image_frame_result.data_length =
-        base::MakeUnique<int>(image_frame.data_length());
-  }
-
-  if (image_frame.has_pixel_data()) {
-    image_frame_result.frame = base::MakeUnique<std::vector<char>>(
-        image_frame.pixel_data().begin(), image_frame.pixel_data().end());
-  }
-
-  image_frame_result.format = ImageFormatProtoToIdl(image_frame);
-  return image_frame_result;
-}
-
-PerceptionSample PerceptionSampleProtoToIdl(
-    const mri::PerceptionSample& perception_sample) {
-  PerceptionSample perception_sample_result;
-  if (perception_sample.has_frame_perception()) {
-    perception_sample_result.frame_perception =
-        base::MakeUnique<FramePerception>(
-            FramePerceptionProtoToIdl(perception_sample.frame_perception()));
-  }
-  if (perception_sample.has_image_frame()) {
-    perception_sample_result.image_frame = base::MakeUnique<ImageFrame>(
-        ImageFrameProtoToIdl(perception_sample.image_frame()));
-  }
-  return perception_sample_result;
-}
-
-Status StateStatusProtoToIdl(const mri::State& state) {
-  switch (state.status()) {
-    case mri::State::UNINITIALIZED:
-      return STATUS_UNINITIALIZED;
-    case mri::State::STARTED:
-      return STATUS_STARTED;
-    case mri::State::RUNNING:
-      return STATUS_RUNNING;
-    case mri::State::SUSPENDED:
-      return STATUS_SUSPENDED;
-    case mri::State::STATUS_UNSPECIFIED:
-      return STATUS_NONE;
-  }
-  NOTREACHED() << "Reached status not in switch.";
-  return STATUS_NONE;
-}
-
-mri::State::Status StateStatusIdlToProto(const State& state) {
-  switch (state.status) {
-    case STATUS_UNINITIALIZED:
-      return mri::State::UNINITIALIZED;
-    case STATUS_STARTED:
-      return mri::State::STARTED;
-    case STATUS_RUNNING:
-      return mri::State::RUNNING;
-    case STATUS_SUSPENDED:
-      return mri::State::SUSPENDED;
-    case STATUS_NONE:
-      return mri::State::STATUS_UNSPECIFIED;
-  }
-  NOTREACHED() << "Reached status not in switch.";
-  return mri::State::STATUS_UNSPECIFIED;
-}
-
-}  //  namespace
-
-State StateProtoToIdl(const mri::State& state) {
-  State state_result;
-  if (state.has_status()) {
-    state_result.status = StateStatusProtoToIdl(state);
-  }
-  if (state.has_device_context()) {
-    state_result.device_context =
-        base::MakeUnique<std::string>(state.device_context());
-  }
-  return state_result;
-}
-
-mri::State StateIdlToProto(const State& state) {
-  mri::State state_result;
-  state_result.set_status(StateStatusIdlToProto(state));
-  if (state.device_context)
-    state_result.set_device_context(*state.device_context);
-
-  return state_result;
-}
-
-MediaPerception MediaPerceptionProtoToIdl(
-    const mri::MediaPerception& media_perception) {
-  MediaPerception media_perception_result;
-  if (media_perception.has_timestamp()) {
-    media_perception_result.timestamp =
-        base::MakeUnique<double>(media_perception.timestamp());
-  }
-
-  if (media_perception.frame_perception_size() > 0) {
-    media_perception_result.frame_perceptions =
-        base::MakeUnique<std::vector<FramePerception>>();
-    for (const auto& frame_perception : media_perception.frame_perception()) {
-      media_perception_result.frame_perceptions->emplace_back(
-          FramePerceptionProtoToIdl(frame_perception));
-    }
-  }
-  return media_perception_result;
-}
-
-Diagnostics DiagnosticsProtoToIdl(const mri::Diagnostics& diagnostics) {
-  Diagnostics diagnostics_result;
-  if (diagnostics.perception_sample_size() > 0) {
-    diagnostics_result.perception_samples =
-        base::MakeUnique<std::vector<PerceptionSample>>();
-    for (const auto& perception_sample : diagnostics.perception_sample()) {
-      diagnostics_result.perception_samples->emplace_back(
-          PerceptionSampleProtoToIdl(perception_sample));
-    }
-  }
-  return diagnostics_result;
-}
-
-}  // namespace media_perception_private
-}  // namespace api
-}  // namespace extensions