Adding FEATURE_EDGE_EMBEDDINGS and named_template_arguments messages.

Enabled edge embedding computation in subgraphs via feature
flag. Additionally, the named_template_arguments allows graph template
arguments to be modified at runtime via legacy javascript API until
IPC refactor work is complete. This cl looks to support m72 and should
be deprecated either at the end of beta m72 or early m73.

Bug: 914959, b/120986539
Change-Id: I2b42c0989800afa9339ae8176a1a833c85ddcbdd
Reviewed-on: https://chromium-review.googlesource.com/c/1376812Reviewed-by: Toni Baržić <tbarzic@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Commit-Queue: Brandon Mayer <bmayer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#619659}

chromeos/dbus/proto/media_perception.proto

@@ -94,10 +94,28 @@ message State {
     FEATURE_AUTOZOOM = 1;
     FEATURE_HOTWORD_DETECTION = 2;
     FEATURE_OCCUPANCY_DETECTION = 3;
+    FEATURE_EDGE_EMBEDDINGS = 4;
   }
 
   // A list of enabled media perception features.
   repeated Feature features = 6;
+
+  message NamedTemplateArgument {
+    optional string name = 1;
+    oneof value {
+      string str = 2;
+      double num = 3;
+    }
+  }
+
+  // An optional list of template arguments to be substituted at
+  // run-time.  Each argument present in this list will be set to the
+  // specified values, others will not be changed. Furthermore, nested
+  // arguments (dictionaries) are not supported.
+  // CAUTION: These template args can be used to overwrite the
+  // Feature flags defined above since feature flags are implemented
+  // as numeric template args.
+  repeated NamedTemplateArgument named_template_arguments = 7;
 }
 
 // This is the output of the MediaPerceptionSinkCalculator.

extensions/browser/api/media_perception_private/conversion_utils.cc

@@ -4,7 +4,6 @@
 
 #include "extensions/browser/api/media_perception_private/conversion_utils.h"
 
-
 namespace extensions {
 namespace api {
 namespace media_perception_private {
@@ -535,6 +534,8 @@ Feature FeatureProtoToIdl(int feature) {
       return FEATURE_HOTWORD_DETECTION;
     case mri::State::FEATURE_OCCUPANCY_DETECTION:
       return FEATURE_OCCUPANCY_DETECTION;
+    case mri::State::FEATURE_EDGE_EMBEDDINGS:
+      return FEATURE_EDGE_EMBEDDINGS;
     case mri::State::FEATURE_UNSET:
       return FEATURE_NONE;
   }
@@ -550,6 +551,8 @@ mri::State::Feature FeatureIdlToProto(const Feature& feature) {
       return mri::State::FEATURE_HOTWORD_DETECTION;
     case FEATURE_OCCUPANCY_DETECTION:
       return mri::State::FEATURE_OCCUPANCY_DETECTION;
+    case FEATURE_EDGE_EMBEDDINGS:
+      return mri::State::FEATURE_EDGE_EMBEDDINGS;
     case FEATURE_NONE:
       return mri::State::FEATURE_UNSET;
   }
@@ -557,6 +560,63 @@ mri::State::Feature FeatureIdlToProto(const Feature& feature) {
   return mri::State::FEATURE_UNSET;
 }
 
+base::Value NamedTemplateArgumentValueProtoToValue(
+    const mri::State::NamedTemplateArgument& named_template_argument) {
+  switch (named_template_argument.value_case()) {
+    case mri::State::NamedTemplateArgument::ValueCase::kStr:
+      return base::Value(named_template_argument.str());
+    case mri::State::NamedTemplateArgument::ValueCase::kNum:
+      return base::Value(named_template_argument.num());
+    case mri::State::NamedTemplateArgument::ValueCase::VALUE_NOT_SET:
+      return base::Value();
+  }
+  NOTREACHED() << "Unknown NamedTemplateArgument::ValueCase "
+               << named_template_argument.value_case();
+  return base::Value();
+}
+
+bool NamedTemplateArgumentProtoToIdl(
+    const mri::State::NamedTemplateArgument named_template_argument_proto,
+    NamedTemplateArgument* named_template_argument) {
+  named_template_argument->name =
+      std::make_unique<std::string>(named_template_argument_proto.name());
+
+  base::Value value =
+      NamedTemplateArgumentValueProtoToValue(named_template_argument_proto);
+
+  named_template_argument->value =
+      std::make_unique<NamedTemplateArgument::Value>();
+  if (!NamedTemplateArgument::Value::Populate(
+          value, named_template_argument->value.get())) {
+    return false;
+  }
+
+  return true;
+}
+
+mri::State::NamedTemplateArgument NamedTemplateArgumentIdlToProto(
+    const NamedTemplateArgument& named_template_argument) {
+  mri::State::NamedTemplateArgument named_template_argument_proto;
+
+  if (named_template_argument.name)
+    named_template_argument_proto.set_name(*named_template_argument.name);
+
+  if (named_template_argument.value) {
+    if (named_template_argument.value->as_string) {
+      named_template_argument_proto.set_str(
+          *named_template_argument.value->as_string);
+    } else if (named_template_argument.value->as_number) {
+      named_template_argument_proto.set_num(
+          *named_template_argument.value->as_number);
+    } else {
+      NOTREACHED() << "Failed to convert NamedTemplateARgument::Value IDL to "
+                      "Proto, unkown value type.";
+    }
+  }
+
+  return named_template_argument_proto;
+}
+
 void VideoStreamParamIdlToProto(mri::VideoStreamParam* param_result,
                                 const VideoStreamParam& param) {
   if (param_result == nullptr)
@@ -652,6 +712,22 @@ State StateProtoToIdl(const mri::State& state) {
         state_result.features->emplace_back(feature_result);
     }
   }
+
+  if (state.named_template_arguments_size() > 0) {
+    state_result.named_template_arguments =
+        std::make_unique<std::vector<NamedTemplateArgument>>(
+            state.named_template_arguments_size());
+
+    for (int i = 0; i < state.named_template_arguments_size(); ++i) {
+      const mri::State::NamedTemplateArgument& named_template_argument_proto =
+          state.named_template_arguments(i);
+
+      NamedTemplateArgumentProtoToIdl(
+          named_template_argument_proto,
+          &state_result.named_template_arguments->at(i));
+    }
+  }
+
   return state_result;
 }
 
@@ -681,6 +757,17 @@ mri::State StateIdlToProto(const State& state) {
       state_result.add_features(FeatureIdlToProto(state.features.get()->at(i)));
   }
 
+  if (state.named_template_arguments) {
+    for (const NamedTemplateArgument& named_template_argument_idl :
+         *state.named_template_arguments) {
+      mri::State::NamedTemplateArgument* new_named_template_argument_proto =
+          state_result.add_named_template_arguments();
+
+      *new_named_template_argument_proto =
+          NamedTemplateArgumentIdlToProto(named_template_argument_idl);
+    }
+  }
+
   return state_result;
 }
 

extensions/browser/api/media_perception_private/conversion_utils_unittest.cc

@@ -38,6 +38,15 @@ constexpr float kWhiteboardBottomRightX = 0.85;
 constexpr float kWhiteboardBottomRightY = 0.79;
 constexpr float kWhiteboardAspectRatio = 1.76;
 
+// One numerical value, one empty and one string NamedTemplateArgument
+constexpr unsigned kNamedTemplateArgumentsSize = 3;
+
+constexpr char kNumericalTemplateArgumentName[] = "numerical_template_argument";
+constexpr double kNumericalTemplateArgumentValue = 42;
+constexpr char kStringTemplateArgumentName[] = "string_template_argument";
+constexpr char kStringTemplateArgumentValue[] = "string_value";
+constexpr double kDoubleTolerance = 0.01;
+
 void InitializeVideoStreamParam(media_perception::VideoStreamParam& param,
                                 const std::string& id,
                                 int width,
@@ -518,8 +527,23 @@ TEST(MediaPerceptionConversionUtilsTest, StateProtoToIdl) {
   state.add_features(mri::State::FEATURE_AUTOZOOM);
   state.add_features(mri::State::FEATURE_HOTWORD_DETECTION);
   state.add_features(mri::State::FEATURE_OCCUPANCY_DETECTION);
+  state.add_features(mri::State::FEATURE_EDGE_EMBEDDINGS);
   state.add_features(mri::State::FEATURE_UNSET);
 
+  // Number NamedTemplateArgument.
+  mri::State::NamedTemplateArgument* named_template_argument_proto =
+      state.add_named_template_arguments();
+  named_template_argument_proto->set_name(kNumericalTemplateArgumentName);
+  named_template_argument_proto->set_num(kNumericalTemplateArgumentValue);
+
+  // Empty
+  named_template_argument_proto = state.add_named_template_arguments();
+
+  // String NamedTemplateArgument.
+  named_template_argument_proto = state.add_named_template_arguments();
+  named_template_argument_proto->set_name(kStringTemplateArgumentName);
+  named_template_argument_proto->set_str(kStringTemplateArgumentValue);
+
   media_perception::State state_result =
       media_perception::StateProtoToIdl(state);
   EXPECT_EQ(state_result.status, media_perception::STATUS_RUNNING);
@@ -540,13 +564,42 @@ TEST(MediaPerceptionConversionUtilsTest, StateProtoToIdl) {
 
   ASSERT_TRUE(state_result.features);
   ASSERT_TRUE(state_result.features.get());
-  ASSERT_EQ(state_result.features.get()->size(), 3u);
+  ASSERT_EQ(state_result.features.get()->size(), 4u);
   EXPECT_EQ(state_result.features.get()->at(0),
             media_perception::FEATURE_AUTOZOOM);
   EXPECT_EQ(state_result.features.get()->at(1),
             media_perception::FEATURE_HOTWORD_DETECTION);
   EXPECT_EQ(state_result.features.get()->at(2),
             media_perception::FEATURE_OCCUPANCY_DETECTION);
+  EXPECT_EQ(state_result.features.get()->at(3),
+            media_perception::FEATURE_EDGE_EMBEDDINGS);
+
+  ASSERT_EQ(state_result.named_template_arguments->size(),
+            kNamedTemplateArgumentsSize);
+
+  // Number.
+
+  EXPECT_EQ(*state_result.named_template_arguments->at(0).name,
+            kNumericalTemplateArgumentName);
+  EXPECT_NEAR(*state_result.named_template_arguments->at(0).value->as_number,
+              kNumericalTemplateArgumentValue, kDoubleTolerance);
+  EXPECT_EQ(state_result.named_template_arguments->at(0).value->as_string,
+            nullptr);
+
+  // Empty.
+  EXPECT_EQ(*state_result.named_template_arguments->at(1).name, "");
+  EXPECT_EQ(state_result.named_template_arguments->at(1).value->as_string,
+            nullptr);
+  EXPECT_EQ(state_result.named_template_arguments->at(1).value->as_number,
+            nullptr);
+
+  // String.
+  EXPECT_EQ(*state_result.named_template_arguments->at(2).name,
+            kStringTemplateArgumentName);
+  EXPECT_EQ(state_result.named_template_arguments->at(2).value->as_number,
+            nullptr);
+  EXPECT_EQ(*state_result.named_template_arguments->at(2).value->as_string,
+            kStringTemplateArgumentValue);
 
   state.set_status(mri::State::STARTED);
   state.set_device_context(kTestDeviceContext);
@@ -590,8 +643,31 @@ TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) {
   state.features->emplace_back(media_perception::FEATURE_AUTOZOOM);
   state.features->emplace_back(media_perception::FEATURE_HOTWORD_DETECTION);
   state.features->emplace_back(media_perception::FEATURE_OCCUPANCY_DETECTION);
+  state.features->emplace_back(media_perception::FEATURE_EDGE_EMBEDDINGS);
   state.features->emplace_back(media_perception::FEATURE_NONE);
 
+  // {Number, Empty, String} test cases.
+  state.named_template_arguments =
+      std::make_unique<std::vector<media_perception::NamedTemplateArgument>>(
+          kNamedTemplateArgumentsSize);
+
+  state.named_template_arguments->at(0).name =
+      std::make_unique<std::string>(kNumericalTemplateArgumentName);
+
+  state.named_template_arguments->at(0).value =
+      std::make_unique<media_perception::NamedTemplateArgument::Value>();
+  media_perception::NamedTemplateArgument::Value::Populate(
+      base::Value(kNumericalTemplateArgumentValue),
+      state.named_template_arguments->at(0).value.get());
+
+  state.named_template_arguments->at(2).name =
+      std::make_unique<std::string>(kStringTemplateArgumentName);
+  state.named_template_arguments->at(2).value =
+      std::make_unique<media_perception::NamedTemplateArgument::Value>();
+  media_perception::NamedTemplateArgument::Value::Populate(
+      base::Value(kStringTemplateArgumentValue),
+      state.named_template_arguments->at(2).value.get());
+
   state_proto = StateIdlToProto(state);
   EXPECT_EQ(state_proto.status(), mri::State::RUNNING);
   ASSERT_TRUE(state_proto.has_configuration());
@@ -612,11 +688,29 @@ TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) {
   ASSERT_TRUE(state_proto.whiteboard().has_aspect_ratio());
   EXPECT_EQ(state_proto.whiteboard().aspect_ratio(), kWhiteboardAspectRatio);
 
-  ASSERT_EQ(state_proto.features_size(), 4);
+  ASSERT_EQ(state_proto.features_size(), 5);
   EXPECT_EQ(state_proto.features(0), mri::State::FEATURE_AUTOZOOM);
   EXPECT_EQ(state_proto.features(1), mri::State::FEATURE_HOTWORD_DETECTION);
   EXPECT_EQ(state_proto.features(2), mri::State::FEATURE_OCCUPANCY_DETECTION);
-  EXPECT_EQ(state_proto.features(3), mri::State::FEATURE_UNSET);
+  EXPECT_EQ(state_proto.features(3), mri::State::FEATURE_EDGE_EMBEDDINGS);
+  EXPECT_EQ(state_proto.features(4), mri::State::FEATURE_UNSET);
+
+  ASSERT_EQ(state_proto.named_template_arguments_size(),
+            static_cast<int>(kNamedTemplateArgumentsSize));
+
+  EXPECT_EQ(state_proto.named_template_arguments(0).name(),
+            kNumericalTemplateArgumentName);
+  EXPECT_NEAR(state_proto.named_template_arguments(0).num(),
+              kNumericalTemplateArgumentValue, kDoubleTolerance);
+
+  EXPECT_FALSE(state_proto.named_template_arguments(1).has_name());
+  EXPECT_FALSE(state_proto.named_template_arguments(1).has_str());
+  EXPECT_FALSE(state_proto.named_template_arguments(1).has_num());
+
+  EXPECT_EQ(state_proto.named_template_arguments(2).name(),
+            kStringTemplateArgumentName);
+  EXPECT_EQ(state_proto.named_template_arguments(2).str(),
+            kStringTemplateArgumentValue);
 
   state.status = media_perception::STATUS_SUSPENDED;
   state.device_context = std::make_unique<std::string>(kTestDeviceContext);

extensions/common/api/media_perception_private.idl

@@ -66,7 +66,13 @@ namespace mediaPerceptionPrivate {
   enum Feature {
     AUTOZOOM,
     HOTWORD_DETECTION,
-    OCCUPANCY_DETECTION
+    OCCUPANCY_DETECTION,
+    EDGE_EMBEDDINGS
+  };
+
+  dictionary NamedTemplateArgument {
+    DOMString? name;
+    (DOMString or double)? value;
   };
 
   enum ComponentType {
@@ -207,6 +213,10 @@ namespace mediaPerceptionPrivate {
 
     // A list of enabled media perception features.
     Feature[]? features;
+
+    // A list of named parameters to be substituted at start-up. Will
+    // only have effect when setting state to <code>RUNNING</code>.
+    NamedTemplateArgument[]? namedTemplateArguments;
   };
 
   dictionary BoundingBox {