diff --git a/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc b/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
index 3014007d2a046..219526e3dcbea 100644
--- a/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
+++ b/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
@@ -27,11 +27,11 @@ constexpr char kFullComponentName[] = "rtanalytics-full";
 std::string GetComponentNameForComponentType(
     const extensions::api::media_perception_private::ComponentType& type) {
   switch (type) {
-    case extensions::api::media_perception_private::COMPONENT_TYPE_LIGHT:
+    case extensions::api::media_perception_private::ComponentType::kLight:
       return kLightComponentName;
-    case extensions::api::media_perception_private::COMPONENT_TYPE_FULL:
+    case extensions::api::media_perception_private::ComponentType::kFull:
       return kFullComponentName;
-    case extensions::api::media_perception_private::COMPONENT_TYPE_NONE:
+    case extensions::api::media_perception_private::ComponentType::kNone:
       LOG(ERROR) << "No component type requested.";
       return "";
   }
@@ -45,27 +45,27 @@ GetComponentInstallationErrorForCrOSComponentManagerError(
   switch (error) {
     case component_updater::CrOSComponentManager::Error::ERROR_MAX:
     case component_updater::CrOSComponentManager::Error::NONE:
-      return api::media_perception_private::COMPONENT_INSTALLATION_ERROR_NONE;
+      return api::media_perception_private::ComponentInstallationError::kNone;
     case component_updater::CrOSComponentManager::Error::UNKNOWN_COMPONENT:
-      return api::media_perception_private::
-          COMPONENT_INSTALLATION_ERROR_UNKNOWN_COMPONENT;
+      return api::media_perception_private::ComponentInstallationError::
+          kUnknownComponent;
     case component_updater::CrOSComponentManager::Error::INSTALL_FAILURE:
     case component_updater::CrOSComponentManager::Error::UPDATE_IN_PROGRESS:
-      return api::media_perception_private::
-          COMPONENT_INSTALLATION_ERROR_INSTALL_FAILURE;
+      return api::media_perception_private::ComponentInstallationError::
+          kInstallFailure;
     case component_updater::CrOSComponentManager::Error::MOUNT_FAILURE:
-      return api::media_perception_private::
-          COMPONENT_INSTALLATION_ERROR_MOUNT_FAILURE;
+      return api::media_perception_private::ComponentInstallationError::
+          kMountFailure;
     case component_updater::CrOSComponentManager::Error::
         COMPATIBILITY_CHECK_FAILED:
-      return api::media_perception_private::
-          COMPONENT_INSTALLATION_ERROR_COMPATIBILITY_CHECK_FAILED;
+      return api::media_perception_private::ComponentInstallationError::
+          kCompatibilityCheckFailed;
     case component_updater::CrOSComponentManager::Error::NOT_FOUND:
-      return api::media_perception_private::
-          COMPONENT_INSTALLATION_ERROR_NOT_FOUND;
+      return api::media_perception_private::ComponentInstallationError::
+          kNotFound;
   }
   NOTREACHED() << "Reached component error type not in switch.";
-  return api::media_perception_private::COMPONENT_INSTALLATION_ERROR_NONE;
+  return api::media_perception_private::ComponentInstallationError::kNone;
 }
 
 void OnLoadComponent(
diff --git a/extensions/browser/api/media_perception_private/conversion_utils.cc b/extensions/browser/api/media_perception_private/conversion_utils.cc
index 07083c6d35794..0c06b54137e64 100644
--- a/extensions/browser/api/media_perception_private/conversion_utils.cc
+++ b/extensions/browser/api/media_perception_private/conversion_utils.cc
@@ -24,12 +24,12 @@ Metadata MetadataProtoToIdl(const mri::Metadata& metadata) {
 HotwordType HotwordTypeProtoToIdl(const mri::HotwordDetection::Type& type) {
   switch (type) {
     case mri::HotwordDetection::UNKNOWN_TYPE:
-      return HOTWORD_TYPE_UNKNOWN_TYPE;
+      return HotwordType::kUnknownType;
     case mri::HotwordDetection::OK_GOOGLE:
-      return HOTWORD_TYPE_OK_GOOGLE;
+      return HotwordType::kOkGoogle;
   }
   NOTREACHED() << "Unknown hotword type: " << type;
-  return HOTWORD_TYPE_UNKNOWN_TYPE;
+  return HotwordType::kUnknownType;
 }
 
 Hotword HotwordProtoToIdl(const mri::HotwordDetection::Hotword& hotword) {
@@ -145,22 +145,22 @@ LightCondition LightConditionProtoToIdl(
     const mri::VideoHumanPresenceDetection::LightCondition& condition) {
   switch (condition) {
     case mri::VideoHumanPresenceDetection::UNSPECIFIED:
-      return LIGHT_CONDITION_UNSPECIFIED;
+      return LightCondition::kUnspecified;
     case mri::VideoHumanPresenceDetection::NO_CHANGE:
-      return LIGHT_CONDITION_NO_CHANGE;
+      return LightCondition::kNoChange;
     case mri::VideoHumanPresenceDetection::TURNED_ON:
-      return LIGHT_CONDITION_TURNED_ON;
+      return LightCondition::kTurnedOn;
     case mri::VideoHumanPresenceDetection::TURNED_OFF:
-      return LIGHT_CONDITION_TURNED_OFF;
+      return LightCondition::kTurnedOff;
     case mri::VideoHumanPresenceDetection::DIMMER:
-      return LIGHT_CONDITION_DIMMER;
+      return LightCondition::kDimmer;
     case mri::VideoHumanPresenceDetection::BRIGHTER:
-      return LIGHT_CONDITION_BRIGHTER;
+      return LightCondition::kBrighter;
     case mri::VideoHumanPresenceDetection::BLACK_FRAME:
-      return LIGHT_CONDITION_BLACK_FRAME;
+      return LightCondition::kBlackFrame;
     default:
       NOTREACHED() << "Unknown light condition: " << condition;
-      return LIGHT_CONDITION_UNSPECIFIED;
+      return LightCondition::kUnspecified;
   }
 }
 
@@ -256,15 +256,15 @@ DistanceUnits DistanceUnitsProtoToIdl(const mri::Distance& distance) {
   if (distance.has_units()) {
     switch (distance.units()) {
       case mri::Distance::METERS:
-        return DISTANCE_UNITS_METERS;
+        return DistanceUnits::kMeters;
       case mri::Distance::PIXELS:
-        return DISTANCE_UNITS_PIXELS;
+        return DistanceUnits::kPixels;
       case mri::Distance::UNITS_UNSPECIFIED:
-        return DISTANCE_UNITS_UNSPECIFIED;
+        return DistanceUnits::kUnspecified;
     }
     NOTREACHED() << "Unknown distance units: " << distance.units();
   }
-  return DISTANCE_UNITS_UNSPECIFIED;
+  return DistanceUnits::kUnspecified;
 }
 
 Distance DistanceProtoToIdl(const mri::Distance& distance) {
@@ -280,35 +280,35 @@ Distance DistanceProtoToIdl(const mri::Distance& distance) {
 FramePerceptionType FramePerceptionTypeProtoToIdl(int type) {
   switch (type) {
     case mri::FramePerception::UNKNOWN_TYPE:
-      return FRAME_PERCEPTION_TYPE_UNKNOWN_TYPE;
+      return FramePerceptionType::kUnknownType;
     case mri::FramePerception::FACE_DETECTION:
-      return FRAME_PERCEPTION_TYPE_FACE_DETECTION;
+      return FramePerceptionType::kFaceDetection;
     case mri::FramePerception::PERSON_DETECTION:
-      return FRAME_PERCEPTION_TYPE_PERSON_DETECTION;
+      return FramePerceptionType::kPersonDetection;
     case mri::FramePerception::MOTION_DETECTION:
-      return FRAME_PERCEPTION_TYPE_MOTION_DETECTION;
+      return FramePerceptionType::kMotionDetection;
   }
   NOTREACHED() << "Unknown frame perception type: " << type;
-  return FRAME_PERCEPTION_TYPE_UNKNOWN_TYPE;
+  return FramePerceptionType::kUnknownType;
 }
 
 EntityType EntityTypeProtoToIdl(const mri::Entity& entity) {
   if (entity.has_type()) {
     switch (entity.type()) {
       case mri::Entity::FACE:
-        return ENTITY_TYPE_FACE;
+        return EntityType::kFace;
       case mri::Entity::PERSON:
-        return ENTITY_TYPE_PERSON;
+        return EntityType::kPerson;
       case mri::Entity::MOTION_REGION:
-        return ENTITY_TYPE_MOTION_REGION;
+        return EntityType::kMotionRegion;
       case mri::Entity::LABELED_REGION:
-        return ENTITY_TYPE_LABELED_REGION;
+        return EntityType::kLabeledRegion;
       case mri::Entity::UNSPECIFIED:
-        return ENTITY_TYPE_UNSPECIFIED;
+        return EntityType::kUnspecified;
     }
     NOTREACHED() << "Unknown entity type: " << entity.type();
   }
-  return ENTITY_TYPE_UNSPECIFIED;
+  return EntityType::kUnspecified;
 }
 
 Entity EntityProtoToIdl(const mri::Entity& entity) {
@@ -395,17 +395,17 @@ ImageFormat ImageFormatProtoToIdl(const mri::ImageFrame& image_frame) {
   if (image_frame.has_format()) {
     switch (image_frame.format()) {
       case mri::ImageFrame::RGB:
-        return IMAGE_FORMAT_RAW;
+        return ImageFormat::kRaw;
       case mri::ImageFrame::PNG:
-        return IMAGE_FORMAT_PNG;
+        return ImageFormat::kPng;
       case mri::ImageFrame::JPEG:
-        return IMAGE_FORMAT_JPEG;
+        return ImageFormat::kJpeg;
       case mri::ImageFrame::FORMAT_UNSPECIFIED:
-        return IMAGE_FORMAT_NONE;
+        return ImageFormat::kNone;
     }
     NOTREACHED() << "Unknown image format: " << image_frame.format();
   }
-  return IMAGE_FORMAT_NONE;
+  return ImageFormat::kNone;
 }
 
 ImageFrame ImageFrameProtoToIdl(const mri::ImageFrame& image_frame) {
@@ -459,40 +459,40 @@ PerceptionSample PerceptionSampleProtoToIdl(
 Status StateStatusProtoToIdl(const mri::State& state) {
   switch (state.status()) {
     case mri::State::UNINITIALIZED:
-      return STATUS_UNINITIALIZED;
+      return Status::kUninitialized;
     case mri::State::STARTED:
-      return STATUS_STARTED;
+      return Status::kStarted;
     case mri::State::RUNNING:
-      return STATUS_RUNNING;
+      return Status::kRunning;
     case mri::State::SUSPENDED:
-      return STATUS_SUSPENDED;
+      return Status::kSuspended;
     case mri::State::RESTARTING:
-      return STATUS_RESTARTING;
+      return Status::kRestarting;
     case mri::State::STOPPED:
-      return STATUS_STOPPED;
+      return Status::kStopped;
     case mri::State::STATUS_UNSPECIFIED:
-      return STATUS_NONE;
+      return Status::kNone;
   }
   NOTREACHED() << "Reached status not in switch.";
-  return STATUS_NONE;
+  return Status::kNone;
 }
 
 mri::State::Status StateStatusIdlToProto(const State& state) {
   switch (state.status) {
-    case STATUS_UNINITIALIZED:
+    case Status::kUninitialized:
       return mri::State::UNINITIALIZED;
-    case STATUS_STARTED:
+    case Status::kStarted:
       return mri::State::STARTED;
-    case STATUS_RUNNING:
+    case Status::kRunning:
       return mri::State::RUNNING;
-    case STATUS_SUSPENDED:
+    case Status::kSuspended:
       return mri::State::SUSPENDED;
-    case STATUS_RESTARTING:
+    case Status::kRestarting:
       return mri::State::RESTARTING;
-    case STATUS_STOPPED:  // Process is stopped by MPP.
+    case Status::kStopped:  // Process is stopped by MPP.
       return mri::State::STOPPED;
-    case STATUS_SERVICE_ERROR:
-    case STATUS_NONE:
+    case Status::kServiceError:
+    case Status::kNone:
       return mri::State::STATUS_UNSPECIFIED;
   }
   NOTREACHED() << "Reached status not in switch.";
@@ -502,35 +502,35 @@ mri::State::Status StateStatusIdlToProto(const State& state) {
 Feature FeatureProtoToIdl(int feature) {
   switch (feature) {
     case mri::State::FEATURE_AUTOZOOM:
-      return FEATURE_AUTOZOOM;
+      return Feature::kAutozoom;
     case mri::State::FEATURE_HOTWORD_DETECTION:
-      return FEATURE_HOTWORD_DETECTION;
+      return Feature::kHotwordDetection;
     case mri::State::FEATURE_OCCUPANCY_DETECTION:
-      return FEATURE_OCCUPANCY_DETECTION;
+      return Feature::kOccupancyDetection;
     case mri::State::FEATURE_EDGE_EMBEDDINGS:
-      return FEATURE_EDGE_EMBEDDINGS;
+      return Feature::kEdgeEmbeddings;
     case mri::State::FEATURE_SOFTWARE_CROPPING:
-      return FEATURE_SOFTWARE_CROPPING;
+      return Feature::kSoftwareCropping;
     case mri::State::FEATURE_UNSET:
-      return FEATURE_NONE;
+      return Feature::kNone;
   }
   NOTREACHED() << "Reached feature not in switch.";
-  return FEATURE_NONE;
+  return Feature::kNone;
 }
 
 mri::State::Feature FeatureIdlToProto(const Feature& feature) {
   switch (feature) {
-    case FEATURE_AUTOZOOM:
+    case Feature::kAutozoom:
       return mri::State::FEATURE_AUTOZOOM;
-    case FEATURE_HOTWORD_DETECTION:
+    case Feature::kHotwordDetection:
       return mri::State::FEATURE_HOTWORD_DETECTION;
-    case FEATURE_OCCUPANCY_DETECTION:
+    case Feature::kOccupancyDetection:
       return mri::State::FEATURE_OCCUPANCY_DETECTION;
-    case FEATURE_EDGE_EMBEDDINGS:
+    case Feature::kEdgeEmbeddings:
       return mri::State::FEATURE_EDGE_EMBEDDINGS;
-    case FEATURE_SOFTWARE_CROPPING:
+    case Feature::kSoftwareCropping:
       return mri::State::FEATURE_SOFTWARE_CROPPING;
-    case FEATURE_NONE:
+    case Feature::kNone:
       return mri::State::FEATURE_UNSET;
   }
   NOTREACHED() << "Reached feature not in switch.";
@@ -677,8 +677,9 @@ State StateProtoToIdl(const mri::State& state) {
     state_result.features.emplace();
     for (const auto& feature : state.features()) {
       const Feature feature_result = FeatureProtoToIdl(feature);
-      if (feature_result != FEATURE_NONE)
+      if (feature_result != Feature::kNone) {
         state_result.features->emplace_back(feature_result);
+      }
     }
   }
 
diff --git a/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc b/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc
index acb1861bfac56..8045454ca47d3 100644
--- a/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc
+++ b/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc
@@ -237,12 +237,12 @@ void ValidateFramePerceptionResult(
   EXPECT_EQ(*entity_result_one.id, 6);
   ASSERT_TRUE(entity_result_one.confidence);
   EXPECT_EQ(*entity_result_one.confidence, 7);
-  EXPECT_EQ(entity_result_one.type, media_perception::ENTITY_TYPE_FACE);
+  EXPECT_EQ(entity_result_one.type, media_perception::EntityType::kFace);
 
   const absl::optional<media_perception::Distance>& distance =
       entity_result_one.depth;
   ASSERT_TRUE(distance);
-  EXPECT_EQ(media_perception::DISTANCE_UNITS_METERS, distance->units);
+  EXPECT_EQ(media_perception::DistanceUnits::kMeters, distance->units);
   ASSERT_TRUE(distance->magnitude);
   EXPECT_EQ(7.5f, *distance->magnitude);
 
@@ -253,7 +253,7 @@ void ValidateFramePerceptionResult(
   ASSERT_TRUE(entity_result_two.confidence);
   EXPECT_EQ(*entity_result_two.confidence, 9);
   EXPECT_EQ(entity_result_two.type,
-            media_perception::ENTITY_TYPE_MOTION_REGION);
+            media_perception::EntityType::kMotionRegion);
 
   const absl::optional<media_perception::BoundingBox>& bounding_box_result_one =
       entity_result_one.bounding_box;
@@ -284,7 +284,7 @@ void ValidateFramePerceptionResult(
   ASSERT_TRUE(entity_result_three.entity_label);
   EXPECT_EQ(*entity_result_three.entity_label, kFakeEntityLabel3);
   EXPECT_EQ(entity_result_three.type,
-            media_perception::ENTITY_TYPE_LABELED_REGION);
+            media_perception::EntityType::kLabeledRegion);
 
   // Validate video human presence detection.
   const absl::optional<media_perception::VideoHumanPresenceDetection>&
@@ -294,18 +294,18 @@ void ValidateFramePerceptionResult(
   ASSERT_TRUE(detection_result->motion_detected_likelihood);
   EXPECT_EQ(*detection_result->motion_detected_likelihood, 0.2);
   EXPECT_EQ(detection_result->light_condition,
-            media_perception::LIGHT_CONDITION_BLACK_FRAME);
+            media_perception::LightCondition::kBlackFrame);
   ASSERT_TRUE(detection_result->light_condition_likelihood);
   EXPECT_EQ(*detection_result->light_condition_likelihood, 0.3);
 
   // Validate frame perception types.
   ASSERT_EQ(3u, frame_perception_result.frame_perception_types->size());
   EXPECT_EQ(frame_perception_result.frame_perception_types->at(0),
-            media_perception::FRAME_PERCEPTION_TYPE_FACE_DETECTION);
+            media_perception::FramePerceptionType::kFaceDetection);
   EXPECT_EQ(frame_perception_result.frame_perception_types->at(1),
-            media_perception::FRAME_PERCEPTION_TYPE_PERSON_DETECTION);
+            media_perception::FramePerceptionType::kPersonDetection);
   EXPECT_EQ(frame_perception_result.frame_perception_types->at(2),
-            media_perception::FRAME_PERCEPTION_TYPE_MOTION_DETECTION);
+            media_perception::FramePerceptionType::kMotionDetection);
 }
 
 void ValidateAudioPerceptionResult(
@@ -352,7 +352,7 @@ void ValidateAudioPerceptionResult(
 
   const media_perception::Hotword& hotword_one =
       hotword_detection->hotwords->at(0);
-  EXPECT_EQ(hotword_one.type, media_perception::HOTWORD_TYPE_OK_GOOGLE);
+  EXPECT_EQ(hotword_one.type, media_perception::HotwordType::kOkGoogle);
   ASSERT_TRUE(hotword_one.frame_id);
   EXPECT_EQ(*hotword_one.frame_id, 987);
   ASSERT_TRUE(hotword_one.start_timestamp_ms);
@@ -366,7 +366,7 @@ void ValidateAudioPerceptionResult(
 
   const media_perception::Hotword& hotword_two =
       hotword_detection->hotwords->at(1);
-  EXPECT_EQ(hotword_two.type, media_perception::HOTWORD_TYPE_UNKNOWN_TYPE);
+  EXPECT_EQ(hotword_two.type, media_perception::HotwordType::kUnknownType);
   ASSERT_TRUE(hotword_two.frame_id);
   EXPECT_EQ(*hotword_two.frame_id, 789);
   ASSERT_TRUE(hotword_two.start_timestamp_ms);
@@ -411,7 +411,7 @@ void ValidateFakeImageFrameData(
   EXPECT_EQ(*image_frame_result.data_length, 3);
   ASSERT_TRUE(image_frame_result.frame);
   EXPECT_EQ((*image_frame_result.frame).size(), 4ul);
-  EXPECT_EQ(image_frame_result.format, media_perception::IMAGE_FORMAT_JPEG);
+  EXPECT_EQ(image_frame_result.format, media_perception::ImageFormat::kJpeg);
 }
 
 void ValidatePointIdl(const absl::optional<media_perception::Point>& point,
@@ -551,7 +551,7 @@ TEST(MediaPerceptionConversionUtilsTest, StateProtoToIdl) {
 
   media_perception::State state_result =
       media_perception::StateProtoToIdl(state);
-  EXPECT_EQ(state_result.status, media_perception::STATUS_RUNNING);
+  EXPECT_EQ(state_result.status, media_perception::Status::kRunning);
   ASSERT_TRUE(state_result.configuration);
   EXPECT_EQ(*state_result.configuration, kTestConfiguration);
 
@@ -570,15 +570,15 @@ TEST(MediaPerceptionConversionUtilsTest, StateProtoToIdl) {
   ASSERT_TRUE(state_result.features);
   ASSERT_TRUE(state_result.features);
   ASSERT_EQ(state_result.features->size(), 5u);
-  EXPECT_EQ(state_result.features->at(0), media_perception::FEATURE_AUTOZOOM);
+  EXPECT_EQ(state_result.features->at(0), media_perception::Feature::kAutozoom);
   EXPECT_EQ(state_result.features->at(1),
-            media_perception::FEATURE_HOTWORD_DETECTION);
+            media_perception::Feature::kHotwordDetection);
   EXPECT_EQ(state_result.features->at(2),
-            media_perception::FEATURE_OCCUPANCY_DETECTION);
+            media_perception::Feature::kOccupancyDetection);
   EXPECT_EQ(state_result.features->at(3),
-            media_perception::FEATURE_EDGE_EMBEDDINGS);
+            media_perception::Feature::kEdgeEmbeddings);
   EXPECT_EQ(state_result.features->at(4),
-            media_perception::FEATURE_SOFTWARE_CROPPING);
+            media_perception::Feature::kSoftwareCropping);
 
   ASSERT_EQ(state_result.named_template_arguments->size(),
             kNamedTemplateArgumentsSize);
@@ -608,27 +608,27 @@ TEST(MediaPerceptionConversionUtilsTest, StateProtoToIdl) {
   state.set_status(mri::State::STARTED);
   state.set_device_context(kTestDeviceContext);
   state_result = media_perception::StateProtoToIdl(state);
-  EXPECT_EQ(state_result.status, media_perception::STATUS_STARTED);
+  EXPECT_EQ(state_result.status, media_perception::Status::kStarted);
   ASSERT_TRUE(state_result.device_context);
   EXPECT_EQ(*state_result.device_context, kTestDeviceContext);
 
   state.set_status(mri::State::RESTARTING);
   state_result = media_perception::StateProtoToIdl(state);
-  EXPECT_EQ(state_result.status, media_perception::STATUS_RESTARTING);
+  EXPECT_EQ(state_result.status, media_perception::Status::kRestarting);
 
   state.set_status(mri::State::STOPPED);
   state_result = media_perception::StateProtoToIdl(state);
-  EXPECT_EQ(state_result.status, media_perception::STATUS_STOPPED);
+  EXPECT_EQ(state_result.status, media_perception::Status::kStopped);
 }
 
 TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) {
   media_perception::State state;
-  state.status = media_perception::STATUS_UNINITIALIZED;
+  state.status = media_perception::Status::kUninitialized;
   mri::State state_proto = StateIdlToProto(state);
   EXPECT_EQ(state_proto.status(), mri::State::UNINITIALIZED);
   EXPECT_FALSE(state_proto.has_device_context());
 
-  state.status = media_perception::STATUS_RUNNING;
+  state.status = media_perception::Status::kRunning;
   state.configuration = kTestConfiguration;
   state.whiteboard.emplace();
   state.whiteboard->top_left =
@@ -642,12 +642,12 @@ TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) {
   state.whiteboard->aspect_ratio = kWhiteboardAspectRatio;
 
   state.features.emplace();
-  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_SOFTWARE_CROPPING);
-  state.features->emplace_back(media_perception::FEATURE_NONE);
+  state.features->emplace_back(media_perception::Feature::kAutozoom);
+  state.features->emplace_back(media_perception::Feature::kHotwordDetection);
+  state.features->emplace_back(media_perception::Feature::kOccupancyDetection);
+  state.features->emplace_back(media_perception::Feature::kEdgeEmbeddings);
+  state.features->emplace_back(media_perception::Feature::kSoftwareCropping);
+  state.features->emplace_back(media_perception::Feature::kNone);
 
   // {Number, Empty, String} test cases.
   state.named_template_arguments =
@@ -712,24 +712,24 @@ TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) {
   EXPECT_EQ(state_proto.named_template_arguments(2).str(),
             kStringTemplateArgumentValue);
 
-  state.status = media_perception::STATUS_SUSPENDED;
+  state.status = media_perception::Status::kSuspended;
   state.device_context = kTestDeviceContext;
   state_proto = StateIdlToProto(state);
   EXPECT_EQ(state_proto.status(), mri::State::SUSPENDED);
   EXPECT_EQ(state_proto.device_context(), kTestDeviceContext);
 
-  state.status = media_perception::STATUS_RESTARTING;
+  state.status = media_perception::Status::kRestarting;
   state_proto = StateIdlToProto(state);
   EXPECT_EQ(state_proto.status(), mri::State::RESTARTING);
 
-  state.status = media_perception::STATUS_STOPPED;
+  state.status = media_perception::Status::kStopped;
   state_proto = StateIdlToProto(state);
   EXPECT_EQ(mri::State::STOPPED, state_proto.status());
 }
 
 TEST(MediaPerceptionConversionUtilsTest, StateIdlToProtoWithVideoStreamParam) {
   media_perception::State state;
-  state.status = media_perception::STATUS_RUNNING;
+  state.status = media_perception::Status::kRunning;
   state.video_stream_param = std::vector<media_perception::VideoStreamParam>(2);
   InitializeVideoStreamParam(
       state.video_stream_param->at(0), kVideoStreamIdForFaceDetection,
diff --git a/extensions/browser/api/media_perception_private/media_perception_api_manager.cc b/extensions/browser/api/media_perception_private/media_perception_api_manager.cc
index 9bad0a2741480..a552aae6e4458 100644
--- a/extensions/browser/api/media_perception_private/media_perception_api_manager.cc
+++ b/extensions/browser/api/media_perception_private/media_perception_api_manager.cc
@@ -37,7 +37,7 @@ extensions::api::media_perception_private::State GetStateForServiceError(
         service_error) {
   extensions::api::media_perception_private::State state;
   state.status =
-      extensions::api::media_perception_private::STATUS_SERVICE_ERROR;
+      extensions::api::media_perception_private::Status::kServiceError;
   state.service_error = service_error;
   return state;
 }
@@ -48,7 +48,7 @@ GetProcessStateForServiceError(
         service_error) {
   extensions::api::media_perception_private::ProcessState process_state;
   process_state.status =
-      extensions::api::media_perception_private::PROCESS_STATUS_SERVICE_ERROR;
+      extensions::api::media_perception_private::ProcessStatus::kServiceError;
   process_state.service_error = service_error;
   return process_state;
 }
@@ -66,7 +66,7 @@ extensions::api::media_perception_private::ComponentState
 GetFailedToInstallComponentState() {
   extensions::api::media_perception_private::ComponentState component_state;
   component_state.status = extensions::api::media_perception_private::
-      COMPONENT_STATUS_FAILED_TO_INSTALL;
+      ComponentStatus::kFailedToInstall;
   return component_state;
 }
 
@@ -169,14 +169,14 @@ void MediaPerceptionAPIManager::GetState(APIStateCallback callback) {
       AnalyticsProcessState::CHANGING_PROCESS_STATE) {
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_BUSY_LAUNCHING));
+                                    ServiceError::kServiceBusyLaunching));
     return;
   }
 
   // Calling getState with process not running returns State UNINITIALIZED.
   extensions::api::media_perception_private::State state_uninitialized;
   state_uninitialized.status =
-      extensions::api::media_perception_private::STATUS_UNINITIALIZED;
+      extensions::api::media_perception_private::Status::kUninitialized;
   std::move(callback).Run(std::move(state_uninitialized));
 }
 
@@ -203,7 +203,7 @@ void MediaPerceptionAPIManager::LoadComponentCallback(
         installation_error,
     const base::FilePath& mount_point) {
   if (installation_error != extensions::api::media_perception_private::
-                                COMPONENT_INSTALLATION_ERROR_NONE) {
+                                ComponentInstallationError::kNone) {
     extensions::api::media_perception_private::ComponentState component_state =
         GetFailedToInstallComponentState();
     component_state.installation_error_code = installation_error;
@@ -216,7 +216,7 @@ void MediaPerceptionAPIManager::LoadComponentCallback(
 
   extensions::api::media_perception_private::ComponentState component_state;
   component_state.status =
-      extensions::api::media_perception_private::COMPONENT_STATUS_INSTALLED;
+      extensions::api::media_perception_private::ComponentStatus::kInstalled;
   component_state.version = ExtractVersionFromMountPoint(mount_point_);
   std::move(callback).Run(std::move(component_state));
   return;
@@ -228,20 +228,20 @@ void MediaPerceptionAPIManager::SetComponentProcessState(
     APIComponentProcessStateCallback callback) {
   DCHECK(
       process_state.status ==
-          extensions::api::media_perception_private::PROCESS_STATUS_STARTED ||
+          extensions::api::media_perception_private::ProcessStatus::kStarted ||
       process_state.status ==
-          extensions::api::media_perception_private::PROCESS_STATUS_STOPPED);
+          extensions::api::media_perception_private::ProcessStatus::kStopped);
   if (analytics_process_state_ ==
       AnalyticsProcessState::CHANGING_PROCESS_STATE) {
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_SERVICE_BUSY_LAUNCHING));
+        extensions::api::media_perception_private::ServiceError::
+            kServiceBusyLaunching));
     return;
   }
 
   analytics_process_state_ = AnalyticsProcessState::CHANGING_PROCESS_STATE;
   if (process_state.status ==
-      extensions::api::media_perception_private::PROCESS_STATUS_STOPPED) {
+      extensions::api::media_perception_private::ProcessStatus::kStopped) {
     base::OnceCallback<void(bool)> stop_callback =
         base::BindOnce(&MediaPerceptionAPIManager::UpstartStopProcessCallback,
                        weak_ptr_factory_.GetWeakPtr(), std::move(callback));
@@ -250,14 +250,14 @@ void MediaPerceptionAPIManager::SetComponentProcessState(
   }
 
   if (process_state.status ==
-      extensions::api::media_perception_private::PROCESS_STATUS_STARTED) {
+      extensions::api::media_perception_private::ProcessStatus::kStarted) {
     // Check if a component is loaded and add the necessary mount_point
     // information to the Upstart start command.
     if (mount_point_.empty()) {
       analytics_process_state_ = AnalyticsProcessState::IDLE;
       std::move(callback).Run(GetProcessStateForServiceError(
-          extensions::api::media_perception_private::
-              SERVICE_ERROR_SERVICE_NOT_INSTALLED));
+          extensions::api::media_perception_private::ServiceError::
+              kServiceNotInstalled));
       return;
     }
 
@@ -274,7 +274,7 @@ void MediaPerceptionAPIManager::SetComponentProcessState(
   analytics_process_state_ = AnalyticsProcessState::IDLE;
   std::move(callback).Run(
       GetProcessStateForServiceError(extensions::api::media_perception_private::
-                                         SERVICE_ERROR_SERVICE_NOT_RUNNING));
+                                         ServiceError::kServiceNotRunning));
 }
 
 void MediaPerceptionAPIManager::SetState(
@@ -292,7 +292,7 @@ void MediaPerceptionAPIManager::SetState(
       AnalyticsProcessState::CHANGING_PROCESS_STATE) {
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_BUSY_LAUNCHING));
+                                    ServiceError::kServiceBusyLaunching));
     return;
   }
 
@@ -346,7 +346,7 @@ void MediaPerceptionAPIManager::SetState(
 
   std::move(callback).Run(
       GetStateForServiceError(extensions::api::media_perception_private::
-                                  SERVICE_ERROR_SERVICE_NOT_RUNNING));
+                                  ServiceError::kServiceNotRunning));
 }
 
 void MediaPerceptionAPIManager::SetStateInternal(APIStateCallback callback,
@@ -370,8 +370,8 @@ void MediaPerceptionAPIManager::UpstartStartProcessCallback(
   if (!succeeded) {
     analytics_process_state_ = AnalyticsProcessState::IDLE;
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_SERVICE_NOT_RUNNING));
+        extensions::api::media_perception_private::ServiceError::
+            kServiceNotRunning));
     return;
   }
 
@@ -400,8 +400,8 @@ void MediaPerceptionAPIManager::SendMojoInvitation(
   if (!delegate) {
     DLOG(WARNING) << "Could not get MediaPerceptionAPIDelegate.";
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+        extensions::api::media_perception_private::ServiceError::
+            kMojoConnectionFailure));
     return;
   }
 
@@ -433,15 +433,15 @@ void MediaPerceptionAPIManager::OnBootstrapMojoConnection(
   if (!succeeded) {
     analytics_process_state_ = AnalyticsProcessState::UNKNOWN;
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+        extensions::api::media_perception_private::ServiceError::
+            kMojoConnectionFailure));
     return;
   }
 
   analytics_process_state_ = AnalyticsProcessState::RUNNING;
   extensions::api::media_perception_private::ProcessState state_started;
   state_started.status =
-      extensions::api::media_perception_private::PROCESS_STATUS_STARTED;
+      extensions::api::media_perception_private::ProcessStatus::kStarted;
 
   // Check if the extensions api client is available in this context. Code path
   // used for testing.
@@ -456,16 +456,16 @@ void MediaPerceptionAPIManager::OnBootstrapMojoConnection(
   if (!delegate) {
     DLOG(WARNING) << "Could not get MediaPerceptionAPIDelegate.";
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+        extensions::api::media_perception_private::ServiceError::
+            kMojoConnectionFailure));
     return;
   }
 
   if (!media_perception_service_.is_bound()) {
     DLOG(WARNING) << "MediaPerceptionService interface not bound.";
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+        extensions::api::media_perception_private::ServiceError::
+            kMojoConnectionFailure));
     return;
   }
 
@@ -494,15 +494,15 @@ void MediaPerceptionAPIManager::UpstartStopProcessCallback(
   if (!succeeded) {
     analytics_process_state_ = AnalyticsProcessState::UNKNOWN;
     std::move(callback).Run(GetProcessStateForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_SERVICE_UNREACHABLE));
+        extensions::api::media_perception_private::ServiceError::
+            kServiceUnreachable));
     return;
   }
   analytics_process_state_ = AnalyticsProcessState::IDLE;
   // Stopping the process succeeded so fire a callback with status STOPPED.
   extensions::api::media_perception_private::ProcessState state_stopped;
   state_stopped.status =
-      extensions::api::media_perception_private::PROCESS_STATUS_STOPPED;
+      extensions::api::media_perception_private::ProcessStatus::kStopped;
   std::move(callback).Run(std::move(state_stopped));
 }
 
@@ -513,7 +513,7 @@ void MediaPerceptionAPIManager::UpstartStartCallback(APIStateCallback callback,
     analytics_process_state_ = AnalyticsProcessState::IDLE;
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_NOT_RUNNING));
+                                    ServiceError::kServiceNotRunning));
     return;
   }
   analytics_process_state_ = AnalyticsProcessState::RUNNING;
@@ -526,14 +526,14 @@ void MediaPerceptionAPIManager::UpstartStopCallback(APIStateCallback callback,
     analytics_process_state_ = AnalyticsProcessState::UNKNOWN;
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_UNREACHABLE));
+                                    ServiceError::kServiceUnreachable));
     return;
   }
   analytics_process_state_ = AnalyticsProcessState::IDLE;
   // Stopping the process succeeded so fire a callback with status STOPPED.
   extensions::api::media_perception_private::State state_stopped;
   state_stopped.status =
-      extensions::api::media_perception_private::STATUS_STOPPED;
+      extensions::api::media_perception_private::Status::kStopped;
   std::move(callback).Run(std::move(state_stopped));
 }
 
@@ -544,7 +544,7 @@ void MediaPerceptionAPIManager::UpstartRestartCallback(
     analytics_process_state_ = AnalyticsProcessState::IDLE;
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_NOT_RUNNING));
+                                    ServiceError::kServiceNotRunning));
     return;
   }
   analytics_process_state_ = AnalyticsProcessState::RUNNING;
@@ -557,7 +557,7 @@ void MediaPerceptionAPIManager::StateCallback(
   if (!result.has_value()) {
     std::move(callback).Run(
         GetStateForServiceError(extensions::api::media_perception_private::
-                                    SERVICE_ERROR_SERVICE_UNREACHABLE));
+                                    ServiceError::kServiceUnreachable));
     return;
   }
   std::move(callback).Run(
@@ -570,8 +570,8 @@ void MediaPerceptionAPIManager::GetDiagnosticsCallback(
     absl::optional<mri::Diagnostics> result) {
   if (!result.has_value()) {
     std::move(callback).Run(GetDiagnosticsForServiceError(
-        extensions::api::media_perception_private::
-            SERVICE_ERROR_SERVICE_UNREACHABLE));
+        extensions::api::media_perception_private::ServiceError::
+            kServiceUnreachable));
     return;
   }
   std::move(callback).Run(
diff --git a/extensions/browser/api/media_perception_private/media_perception_api_manager_unittest.cc b/extensions/browser/api/media_perception_private/media_perception_api_manager_unittest.cc
index bc9bce7372eb4..d683a96013b2e 100644
--- a/extensions/browser/api/media_perception_private/media_perception_api_manager_unittest.cc
+++ b/extensions/browser/api/media_perception_private/media_perception_api_manager_unittest.cc
@@ -196,7 +196,7 @@ class MediaPerceptionAPIManagerTest : public testing::Test {
 TEST_F(MediaPerceptionAPIManagerTest, UpstartFailure) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::State state;
-  state.status = media_perception::STATUS_RUNNING;
+  state.status = media_perception::Status::kRunning;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -205,18 +205,18 @@ TEST_F(MediaPerceptionAPIManagerTest, UpstartFailure) {
                                     run_loop.QuitClosure(), &service_error));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(false));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_NOT_RUNNING, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kServiceNotRunning, service_error);
 
   // Check that after a failed request, setState RUNNING will go through.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
 }
 
 TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartFailure) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::ProcessState process_state;
-  process_state.status = media_perception::PROCESS_STATUS_STARTED;
+  process_state.status = media_perception::ProcessStatus::kStarted;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -226,11 +226,11 @@ TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartFailure) {
                      run_loop.QuitClosure(), &service_error));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(false));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_NOT_RUNNING, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kServiceNotRunning, service_error);
 
   // Check that after a failed request, setState RUNNING will go through.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetComponentProcessStateAndWaitForResponse(manager_.get(),
                                                        process_state));
 }
@@ -238,7 +238,7 @@ TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartFailure) {
 TEST_F(MediaPerceptionAPIManagerTest, UpstartStopFailure) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::State state;
-  state.status = media_perception::STATUS_STOPPED;
+  state.status = media_perception::Status::kStopped;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -247,18 +247,18 @@ TEST_F(MediaPerceptionAPIManagerTest, UpstartStopFailure) {
                                     run_loop.QuitClosure(), &service_error));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(false));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_UNREACHABLE, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kServiceUnreachable, service_error);
 
   // Check that after a failed request, STOPPED will go through.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
 }
 
 TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartStopFailure) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::ProcessState process_state;
-  process_state.status = media_perception::PROCESS_STATUS_STOPPED;
+  process_state.status = media_perception::ProcessStatus::kStopped;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -268,11 +268,11 @@ TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartStopFailure) {
                      run_loop.QuitClosure(), &service_error));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(false));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_UNREACHABLE, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kServiceUnreachable, service_error);
 
   // Check that after a failed request, STOPPED will go through.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetComponentProcessStateAndWaitForResponse(manager_.get(),
                                                        process_state));
 }
@@ -280,7 +280,7 @@ TEST_F(MediaPerceptionAPIManagerTest, ProcessStateUpstartStopFailure) {
 TEST_F(MediaPerceptionAPIManagerTest, UpstartRestartFailure) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::State state;
-  state.status = media_perception::STATUS_RESTARTING;
+  state.status = media_perception::Status::kRestarting;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -289,19 +289,19 @@ TEST_F(MediaPerceptionAPIManagerTest, UpstartRestartFailure) {
                                     run_loop.QuitClosure(), &service_error));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(false));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_NOT_RUNNING, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kServiceNotRunning, service_error);
 
   // Check that after a failed request, setState restarted will still go
   // through.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
 }
 
 TEST_F(MediaPerceptionAPIManagerTest, UpstartStall) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::State state;
-  state.status = media_perception::STATUS_RUNNING;
+  state.status = media_perception::Status::kRunning;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -309,27 +309,27 @@ TEST_F(MediaPerceptionAPIManagerTest, UpstartStall) {
                      base::BindOnce(&RecordServiceErrorFromStateAndRunClosure,
                                     run_loop.QuitClosure(), &service_error));
 
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_BUSY_LAUNCHING,
+  EXPECT_EQ(media_perception::ServiceError::kServiceBusyLaunching,
             GetStateAndWaitForResponse(manager_.get()));
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_BUSY_LAUNCHING,
+  EXPECT_EQ(media_perception::ServiceError::kServiceBusyLaunching,
             SetStateAndWaitForResponse(manager_.get(), state));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(true));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kNone, service_error);
 
   // Verify that after the slow start, things works as normal.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             GetStateAndWaitForResponse(manager_.get()));
-  state.status = media_perception::STATUS_SUSPENDED;
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  state.status = media_perception::Status::kSuspended;
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
 }
 
 TEST_F(MediaPerceptionAPIManagerTest, SetComponentProcessStateUpstartStall) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::ProcessState process_state;
-  process_state.status = media_perception::PROCESS_STATUS_STARTED;
+  process_state.status = media_perception::ProcessStatus::kStarted;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -338,24 +338,24 @@ TEST_F(MediaPerceptionAPIManagerTest, SetComponentProcessStateUpstartStall) {
       base::BindOnce(&RecordServiceErrorFromProcessStateAndRunClosure,
                      run_loop.QuitClosure(), &service_error));
 
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_BUSY_LAUNCHING,
+  EXPECT_EQ(media_perception::ServiceError::kServiceBusyLaunching,
             SetComponentProcessStateAndWaitForResponse(manager_.get(),
                                                        process_state));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(true));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kNone, service_error);
 
   // Verify that after the slow start, things works as normal.
   upstart_client()->set_enqueue_requests(false);
-  process_state.status = media_perception::PROCESS_STATUS_STARTED;
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  process_state.status = media_perception::ProcessStatus::kStarted;
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetComponentProcessStateAndWaitForResponse(manager_.get(),
                                                        process_state));
 }
 TEST_F(MediaPerceptionAPIManagerTest, UpstartRestartStall) {
   upstart_client()->set_enqueue_requests(true);
   media_perception::State state;
-  state.status = media_perception::STATUS_RESTARTING;
+  state.status = media_perception::Status::kRestarting;
 
   base::RunLoop run_loop;
   media_perception::ServiceError service_error;
@@ -363,36 +363,36 @@ TEST_F(MediaPerceptionAPIManagerTest, UpstartRestartStall) {
                      base::BindOnce(&RecordServiceErrorFromStateAndRunClosure,
                                     run_loop.QuitClosure(), &service_error));
 
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_BUSY_LAUNCHING,
+  EXPECT_EQ(media_perception::ServiceError::kServiceBusyLaunching,
             GetStateAndWaitForResponse(manager_.get()));
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_BUSY_LAUNCHING,
+  EXPECT_EQ(media_perception::ServiceError::kServiceBusyLaunching,
             SetStateAndWaitForResponse(manager_.get(), state));
   EXPECT_TRUE(upstart_client()->HandleNextUpstartRequest(true));
   run_loop.Run();
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE, service_error);
+  EXPECT_EQ(media_perception::ServiceError::kNone, service_error);
 
   // Verify that after the slow start, things works as normal.
   upstart_client()->set_enqueue_requests(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             GetStateAndWaitForResponse(manager_.get()));
-  state.status = media_perception::STATUS_RUNNING;
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  state.status = media_perception::Status::kRunning;
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
 }
 
 TEST_F(MediaPerceptionAPIManagerTest, MediaAnalyticsDbusError) {
   media_perception::State state;
-  state.status = media_perception::STATUS_RUNNING;
-  EXPECT_EQ(media_perception::SERVICE_ERROR_NONE,
+  state.status = media_perception::Status::kRunning;
+  EXPECT_EQ(media_perception::ServiceError::kNone,
             SetStateAndWaitForResponse(manager_.get(), state));
   // Disable the functionality of the fake process.
   ash::FakeMediaAnalyticsClient::Get()->set_process_running(false);
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_UNREACHABLE,
+  EXPECT_EQ(media_perception::ServiceError::kServiceUnreachable,
             GetStateAndWaitForResponse(manager_.get()));
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_UNREACHABLE,
+  EXPECT_EQ(media_perception::ServiceError::kServiceUnreachable,
             SetStateAndWaitForResponse(manager_.get(), state));
   // Check that getting diagnostics also errors in the same way.
-  EXPECT_EQ(media_perception::SERVICE_ERROR_SERVICE_UNREACHABLE,
+  EXPECT_EQ(media_perception::ServiceError::kServiceUnreachable,
             GetDiagnosticsAndWaitForResponse(manager_.get()));
 }
 
diff --git a/extensions/browser/api/media_perception_private/media_perception_private_api.cc b/extensions/browser/api/media_perception_private/media_perception_private_api.cc
index e0359ae1f8a0b..ddcd2a8f3393e 100644
--- a/extensions/browser/api/media_perception_private/media_perception_private_api.cc
+++ b/extensions/browser/api/media_perception_private/media_perception_private_api.cc
@@ -41,13 +41,13 @@ MediaPerceptionPrivateSetStateFunction::Run() {
               args());
   EXTENSION_FUNCTION_VALIDATE(params);
   if (params->state.status !=
-          extensions::api::media_perception_private::STATUS_RUNNING &&
+          extensions::api::media_perception_private::Status::kRunning &&
       params->state.status !=
-          extensions::api::media_perception_private::STATUS_SUSPENDED &&
+          extensions::api::media_perception_private::Status::kSuspended &&
       params->state.status !=
-          extensions::api::media_perception_private::STATUS_RESTARTING &&
+          extensions::api::media_perception_private::Status::kRestarting &&
       params->state.status !=
-          extensions::api::media_perception_private::STATUS_STOPPED) {
+          extensions::api::media_perception_private::Status::kStopped) {
     return RespondNow(
         Error("Status can only be set to RUNNING, SUSPENDED, RESTARTING, or "
               "STOPPED."));
@@ -55,7 +55,7 @@ MediaPerceptionPrivateSetStateFunction::Run() {
 
   // Check that device context is only provided with SetState RUNNING.
   if (params->state.status !=
-          extensions::api::media_perception_private::STATUS_RUNNING &&
+          extensions::api::media_perception_private::Status::kRunning &&
       params->state.device_context) {
     return RespondNow(
         Error("Only provide deviceContext with SetState RUNNING."));
@@ -63,7 +63,7 @@ MediaPerceptionPrivateSetStateFunction::Run() {
 
   // Check that video stream parameters are only provided with SetState RUNNING.
   if (params->state.status !=
-          extensions::api::media_perception_private::STATUS_RUNNING &&
+          extensions::api::media_perception_private::Status::kRunning &&
       params->state.video_stream_param) {
     return RespondNow(
         Error("SetState: status must be RUNNING to set videoStreamParam."));
@@ -72,14 +72,14 @@ MediaPerceptionPrivateSetStateFunction::Run() {
   // Check that configuration is only provided with SetState RUNNING.
   if (params->state.configuration &&
       params->state.status !=
-          extensions::api::media_perception_private::STATUS_RUNNING) {
+          extensions::api::media_perception_private::Status::kRunning) {
     return RespondNow(Error("Status must be RUNNING to set configuration."));
   }
 
   // Check that whiteboard configuration is only provided with SetState RUNNING.
   if (params->state.whiteboard &&
       params->state.status !=
-          extensions::api::media_perception_private::STATUS_RUNNING) {
+          extensions::api::media_perception_private::Status::kRunning) {
     return RespondNow(Error(
         "Status must be RUNNING to set whiteboard configuration."));
   }
@@ -164,9 +164,9 @@ MediaPerceptionPrivateSetComponentProcessStateFunction::Run() {
           SetComponentProcessState::Params::Create(args());
   EXTENSION_FUNCTION_VALIDATE(params);
   if (params->process_state.status !=
-          extensions::api::media_perception_private::PROCESS_STATUS_STARTED &&
+          extensions::api::media_perception_private::ProcessStatus::kStarted &&
       params->process_state.status !=
-          extensions::api::media_perception_private::PROCESS_STATUS_STOPPED) {
+          extensions::api::media_perception_private::ProcessStatus::kStopped) {
     return RespondNow(
         Error("Cannot set process_state to something other than STARTED or "
               "STOPPED."));
diff --git a/extensions/browser/api/media_perception_private/media_perception_private_apitest.cc b/extensions/browser/api/media_perception_private/media_perception_private_apitest.cc
index 141c997bf4643..d138d1e6b6f25 100644
--- a/extensions/browser/api/media_perception_private/media_perception_private_apitest.cc
+++ b/extensions/browser/api/media_perception_private/media_perception_private_apitest.cc
@@ -34,12 +34,12 @@ class TestMediaPerceptionAPIDelegate : public MediaPerceptionAPIDelegate {
                          LoadCrOSComponentCallback load_callback) override {
     // For testing both success and failure cases, test class has the LIGHT
     // component succeed install and the others fail.
-    if (type == media_perception::COMPONENT_TYPE_LIGHT) {
+    if (type == media_perception::ComponentType::kLight) {
       base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
           FROM_HERE,
           base::BindOnce(
               std::move(load_callback),
-              media_perception::COMPONENT_INSTALLATION_ERROR_NONE,
+              media_perception::ComponentInstallationError::kNone,
               base::FilePath("/run/imageloader/rtanalytics-light/1.0")));
       return;
     }
@@ -47,7 +47,7 @@ class TestMediaPerceptionAPIDelegate : public MediaPerceptionAPIDelegate {
     base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
         FROM_HERE,
         base::BindOnce(std::move(load_callback),
-                       media_perception::COMPONENT_INSTALLATION_ERROR_NOT_FOUND,
+                       media_perception::ComponentInstallationError::kNotFound,
                        base::FilePath()));
   }
 
diff --git a/extensions/common/api/media_perception_private.idl b/extensions/common/api/media_perception_private.idl
index 6563dac20de2d..088be53e200f5 100644
--- a/extensions/common/api/media_perception_private.idl
+++ b/extensions/common/api/media_perception_private.idl
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // Private API for receiving real-time media perception information.
-[platforms=("chromeos")]
+[platforms=("chromeos"), modernised_enums]
 namespace mediaPerceptionPrivate {
   enum Status {
     // The media analytics process is waiting to be launched.