aconfig: introduce namespace, rename proto messages

Flags belong to a namespace. Update the proto files to reflect this.

Config files can only refer to a single namespace. Override files can
refer to multiple namespaces; an override directive for a flag in a
different namespace than the one represented by the cache will be
silently ignored.

Rename the proto messages to make it more clear what they are. Propagate
this change through the wrappers in aconfig.rs and the rest of the code.

Also, settle on Tracepoint instead of TracePoint.

Bug: 279485059
Test: atest aconfig.test
Change-Id: I16e69dd14687bc498b2ba89d6a35879459903801
diff --git a/tools/aconfig/src/aconfig.rs b/tools/aconfig/src/aconfig.rs
index edab36c..8fe82b6 100644
--- a/tools/aconfig/src/aconfig.rs
+++ b/tools/aconfig/src/aconfig.rs
@@ -18,10 +18,11 @@
 use protobuf::{Enum, EnumOrUnknown};
 use serde::{Deserialize, Serialize};
 
-use crate::cache::{Cache, Item, TracePoint};
+use crate::cache::{Cache, Item, Tracepoint};
 use crate::protos::{
-    ProtoAndroidConfig, ProtoDump, ProtoDumpItem, ProtoDumpTracePoint, ProtoFlag, ProtoFlagState,
-    ProtoOverride, ProtoOverrideConfig, ProtoPermission, ProtoValue,
+    ProtoFlagDefinition, ProtoFlagDefinitionValue, ProtoFlagOverride, ProtoFlagOverrides,
+    ProtoFlagPermission, ProtoFlagState, ProtoNamespace, ProtoParsedFlag, ProtoParsedFlags,
+    ProtoTracepoint,
 };
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, Copy)]
@@ -57,23 +58,23 @@
     ReadWrite,
 }
 
-impl TryFrom<EnumOrUnknown<ProtoPermission>> for Permission {
+impl TryFrom<EnumOrUnknown<ProtoFlagPermission>> for Permission {
     type Error = Error;
 
-    fn try_from(proto: EnumOrUnknown<ProtoPermission>) -> Result<Self, Self::Error> {
-        match ProtoPermission::from_i32(proto.value()) {
-            Some(ProtoPermission::READ_ONLY) => Ok(Permission::ReadOnly),
-            Some(ProtoPermission::READ_WRITE) => Ok(Permission::ReadWrite),
+    fn try_from(proto: EnumOrUnknown<ProtoFlagPermission>) -> Result<Self, Self::Error> {
+        match ProtoFlagPermission::from_i32(proto.value()) {
+            Some(ProtoFlagPermission::READ_ONLY) => Ok(Permission::ReadOnly),
+            Some(ProtoFlagPermission::READ_WRITE) => Ok(Permission::ReadWrite),
             None => Err(anyhow!("unknown permission enum value {}", proto.value())),
         }
     }
 }
 
-impl From<Permission> for ProtoPermission {
+impl From<Permission> for ProtoFlagPermission {
     fn from(permission: Permission) -> Self {
         match permission {
-            Permission::ReadOnly => ProtoPermission::READ_ONLY,
-            Permission::ReadWrite => ProtoPermission::READ_WRITE,
+            Permission::ReadOnly => ProtoFlagPermission::READ_ONLY,
+            Permission::ReadWrite => ProtoFlagPermission::READ_WRITE,
         }
     }
 }
@@ -96,10 +97,10 @@
     }
 }
 
-impl TryFrom<ProtoValue> for Value {
+impl TryFrom<ProtoFlagDefinitionValue> for Value {
     type Error = Error;
 
-    fn try_from(proto: ProtoValue) -> Result<Self, Self::Error> {
+    fn try_from(proto: ProtoFlagDefinitionValue) -> Result<Self, Self::Error> {
         let Some(proto_state) = proto.state else {
             return Err(anyhow!("missing 'state' field"));
         };
@@ -114,7 +115,7 @@
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Flag {
-    pub id: String,
+    pub name: String,
     pub description: String,
 
     // ordered by Value.since; guaranteed to contain at least one item (the default value, with
@@ -125,17 +126,11 @@
 impl Flag {
     #[allow(dead_code)] // only used in unit tests
     pub fn try_from_text_proto(text_proto: &str) -> Result<Flag> {
-        let proto: ProtoFlag = crate::protos::try_from_text_proto(text_proto)
+        let proto: ProtoFlagDefinition = crate::protos::try_from_text_proto(text_proto)
             .with_context(|| text_proto.to_owned())?;
         proto.try_into()
     }
 
-    pub fn try_from_text_proto_list(text_proto: &str) -> Result<Vec<Flag>> {
-        let proto: ProtoAndroidConfig = crate::protos::try_from_text_proto(text_proto)
-            .with_context(|| text_proto.to_owned())?;
-        proto.flag.into_iter().map(|proto_flag| proto_flag.try_into()).collect()
-    }
-
     pub fn resolve(&self, build_id: u32) -> (FlagState, Permission) {
         let mut state = self.values[0].state;
         let mut permission = self.values[0].permission;
@@ -150,12 +145,12 @@
     }
 }
 
-impl TryFrom<ProtoFlag> for Flag {
+impl TryFrom<ProtoFlagDefinition> for Flag {
     type Error = Error;
 
-    fn try_from(proto: ProtoFlag) -> Result<Self, Self::Error> {
-        let Some(id) = proto.id else {
-            return Err(anyhow!("missing 'id' field"));
+    fn try_from(proto: ProtoFlagDefinition) -> Result<Self, Self::Error> {
+        let Some(name) = proto.name else {
+            return Err(anyhow!("missing 'name' field"));
         };
         let Some(description) = proto.description else {
             return Err(anyhow!("missing 'description' field"));
@@ -169,8 +164,8 @@
             let v: Value = proto_value.try_into()?;
             if values.iter().any(|w| v.since == w.since) {
                 let msg = match v.since {
-                    None => format!("flag {}: multiple default values", id),
-                    Some(x) => format!("flag {}: multiple values for since={}", id, x),
+                    None => format!("flag {}: multiple default values", name),
+                    Some(x) => format!("flag {}: multiple values for since={}", name, x),
                 };
                 return Err(anyhow!(msg));
             }
@@ -178,13 +173,35 @@
         }
         values.sort_by_key(|v| v.since);
 
-        Ok(Flag { id, description, values })
+        Ok(Flag { name, description, values })
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Namespace {
+    pub namespace: String,
+    pub flags: Vec<Flag>,
+}
+
+impl Namespace {
+    pub fn try_from_text_proto(text_proto: &str) -> Result<Namespace> {
+        let proto: ProtoNamespace = crate::protos::try_from_text_proto(text_proto)
+            .with_context(|| text_proto.to_owned())?;
+        let Some(namespace) = proto.namespace else {
+            return Err(anyhow!("missing 'namespace' field"));
+        };
+        let mut flags = vec![];
+        for proto_flag in proto.flag.into_iter() {
+            flags.push(proto_flag.try_into()?);
+        }
+        Ok(Namespace { namespace, flags })
     }
 }
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Override {
-    pub id: String,
+    pub namespace: String,
+    pub name: String,
     pub state: FlagState,
     pub permission: Permission,
 }
@@ -192,22 +209,25 @@
 impl Override {
     #[allow(dead_code)] // only used in unit tests
     pub fn try_from_text_proto(text_proto: &str) -> Result<Override> {
-        let proto: ProtoOverride = crate::protos::try_from_text_proto(text_proto)?;
+        let proto: ProtoFlagOverride = crate::protos::try_from_text_proto(text_proto)?;
         proto.try_into()
     }
 
     pub fn try_from_text_proto_list(text_proto: &str) -> Result<Vec<Override>> {
-        let proto: ProtoOverrideConfig = crate::protos::try_from_text_proto(text_proto)?;
-        proto.override_.into_iter().map(|proto_flag| proto_flag.try_into()).collect()
+        let proto: ProtoFlagOverrides = crate::protos::try_from_text_proto(text_proto)?;
+        proto.flag_override.into_iter().map(|proto_flag| proto_flag.try_into()).collect()
     }
 }
 
-impl TryFrom<ProtoOverride> for Override {
+impl TryFrom<ProtoFlagOverride> for Override {
     type Error = Error;
 
-    fn try_from(proto: ProtoOverride) -> Result<Self, Self::Error> {
-        let Some(id) = proto.id else {
-            return Err(anyhow!("missing 'id' field"));
+    fn try_from(proto: ProtoFlagOverride) -> Result<Self, Self::Error> {
+        let Some(namespace) = proto.namespace else {
+            return Err(anyhow!("missing 'namespace' field"));
+        };
+        let Some(name) = proto.name else {
+            return Err(anyhow!("missing 'name' field"));
         };
         let Some(proto_state) = proto.state else {
             return Err(anyhow!("missing 'state' field"));
@@ -217,41 +237,42 @@
             return Err(anyhow!("missing 'permission' field"));
         };
         let permission = proto_permission.try_into()?;
-        Ok(Override { id, state, permission })
+        Ok(Override { namespace, name, state, permission })
     }
 }
 
-impl From<Cache> for ProtoDump {
+impl From<Cache> for ProtoParsedFlags {
     fn from(cache: Cache) -> Self {
-        let mut dump = ProtoDump::new();
+        let mut proto = ProtoParsedFlags::new();
         for item in cache.into_iter() {
-            dump.item.push(item.into());
+            proto.parsed_flag.push(item.into());
         }
-        dump
+        proto
     }
 }
 
-impl From<Item> for ProtoDumpItem {
+impl From<Item> for ProtoParsedFlag {
     fn from(item: Item) -> Self {
-        let mut dump_item = crate::protos::ProtoDumpItem::new();
-        dump_item.set_id(item.id.clone());
-        dump_item.set_description(item.description.clone());
-        dump_item.set_state(item.state.into());
-        dump_item.set_permission(item.permission.into());
+        let mut proto = crate::protos::ProtoParsedFlag::new();
+        proto.set_namespace(item.namespace.to_owned());
+        proto.set_name(item.name.clone());
+        proto.set_description(item.description.clone());
+        proto.set_state(item.state.into());
+        proto.set_permission(item.permission.into());
         for trace in item.trace.into_iter() {
-            dump_item.trace.push(trace.into());
+            proto.trace.push(trace.into());
         }
-        dump_item
+        proto
     }
 }
 
-impl From<TracePoint> for ProtoDumpTracePoint {
-    fn from(tracepoint: TracePoint) -> Self {
-        let mut dump_tracepoint = ProtoDumpTracePoint::new();
-        dump_tracepoint.set_source(format!("{}", tracepoint.source));
-        dump_tracepoint.set_state(tracepoint.state.into());
-        dump_tracepoint.set_permission(tracepoint.permission.into());
-        dump_tracepoint
+impl From<Tracepoint> for ProtoTracepoint {
+    fn from(tracepoint: Tracepoint) -> Self {
+        let mut proto = ProtoTracepoint::new();
+        proto.set_source(format!("{}", tracepoint.source));
+        proto.set_state(tracepoint.state.into());
+        proto.set_permission(tracepoint.permission.into());
+        proto
     }
 }
 
@@ -262,7 +283,7 @@
     #[test]
     fn test_flag_try_from_text_proto() {
         let expected = Flag {
-            id: "1234".to_owned(),
+            name: "1234".to_owned(),
             description: "Description of the flag".to_owned(),
             values: vec![
                 Value::default(FlagState::Disabled, Permission::ReadOnly),
@@ -271,7 +292,7 @@
         };
 
         let s = r#"
-        id: "1234"
+        name: "1234"
         description: "Description of the flag"
         value {
             state: DISABLED
@@ -291,7 +312,7 @@
     #[test]
     fn test_flag_try_from_text_proto_bad_input() {
         let s = r#"
-        id: "a"
+        name: "a"
         description: "Description of the flag"
         "#;
         let error = Flag::try_from_text_proto(s).unwrap_err();
@@ -308,7 +329,7 @@
         assert!(format!("{:?}", error).contains("Message not initialized"));
 
         let s = r#"
-        id: "a"
+        name: "a"
         description: "Description of the flag"
         value {
             state: ENABLED
@@ -324,23 +345,27 @@
     }
 
     #[test]
-    fn test_flag_try_from_text_proto_list() {
-        let expected = vec![
-            Flag {
-                id: "a".to_owned(),
-                description: "A".to_owned(),
-                values: vec![Value::default(FlagState::Enabled, Permission::ReadOnly)],
-            },
-            Flag {
-                id: "b".to_owned(),
-                description: "B".to_owned(),
-                values: vec![Value::default(FlagState::Disabled, Permission::ReadWrite)],
-            },
-        ];
+    fn test_namespace_try_from_text_proto() {
+        let expected = Namespace {
+            namespace: "ns".to_owned(),
+            flags: vec![
+                Flag {
+                    name: "a".to_owned(),
+                    description: "A".to_owned(),
+                    values: vec![Value::default(FlagState::Enabled, Permission::ReadOnly)],
+                },
+                Flag {
+                    name: "b".to_owned(),
+                    description: "B".to_owned(),
+                    values: vec![Value::default(FlagState::Disabled, Permission::ReadWrite)],
+                },
+            ],
+        };
 
         let s = r#"
+        namespace: "ns"
         flag {
-            id: "a"
+            name: "a"
             description: "A"
             value {
                 state: ENABLED
@@ -348,7 +373,7 @@
             }
         }
         flag {
-            id: "b"
+            name: "b"
             description: "B"
             value {
                 state: DISABLED
@@ -356,7 +381,7 @@
             }
         }
         "#;
-        let actual = Flag::try_from_text_proto_list(s).unwrap();
+        let actual = Namespace::try_from_text_proto(s).unwrap();
 
         assert_eq!(expected, actual);
     }
@@ -364,13 +389,15 @@
     #[test]
     fn test_override_try_from_text_proto_list() {
         let expected = Override {
-            id: "1234".to_owned(),
+            namespace: "ns".to_owned(),
+            name: "1234".to_owned(),
             state: FlagState::Enabled,
             permission: Permission::ReadOnly,
         };
 
         let s = r#"
-        id: "1234"
+        namespace: "ns"
+        name: "1234"
         state: ENABLED
         permission: READ_ONLY
         "#;
@@ -382,7 +409,7 @@
     #[test]
     fn test_flag_resolve() {
         let flag = Flag {
-            id: "a".to_owned(),
+            name: "a".to_owned(),
             description: "A".to_owned(),
             values: vec![
                 Value::default(FlagState::Disabled, Permission::ReadOnly),