[component_manager] *_routed_async functions take PartialAbsoluteMoniker

This CL refactors the calls in these functions:

- `on_scoped_framework_capability_routed_async` in binder.rs
- `on_collection_capability_routed_async` in collection.rs

.. to take a `PartialAbsoluteMoniker` directly, instead of an
`AbsoluteMoniker` that eventually gets converted with `.to_partial()`.

Additionally the unused AbsoluteMoniker parameter is removed from
`on_capability_routed_async` in hub.rs

The reason for this CL is to reduce the scope of `AbsoluteMoniker`, when
using `PartialAbsoluteMoniker` can be used directly instead.

Bug: 87407
Change-Id: I0f2eb836205aa9b20035fe35e868eaad21461722
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/637493
Reviewed-by: Yegor Pomortsev <[email protected]>
Commit-Queue: Caslyn Tonelli <[email protected]>

Author: Caslyn

src/sys/component_manager/src/binder.rs

@@ -19,7 +19,7 @@ use {
     cm_util::channel,
     fuchsia_zircon as zx,
     lazy_static::lazy_static,
-    moniker::{AbsoluteMoniker, AbsoluteMonikerBase, ExtendedMoniker},
+    moniker::{AbsoluteMonikerBase, ExtendedMoniker, PartialAbsoluteMoniker},
     routing::capability_source::{ComponentCapability, InternalCapability},
     std::{
         path::PathBuf,
@@ -115,16 +115,15 @@ impl BinderCapabilityHost {
     async fn on_scoped_framework_capability_routed_async<'a>(
         self: Arc<Self>,
         source: WeakComponentInstance,
-        target_moniker: AbsoluteMoniker,
+        target_moniker: PartialAbsoluteMoniker,
         capability: &'a InternalCapability,
         capability_provider: Option<Box<dyn CapabilityProvider>>,
     ) -> Result<Option<Box<dyn CapabilityProvider>>, ModelError> {
         // If some other capability has already been installed, then there's nothing to
         // do here.
         if capability_provider.is_none() && capability.matches_protocol(&BINDER_SERVICE) {
             let model = self.model.upgrade().ok_or(ModelError::ModelNotAvailable)?;
-            let target =
-                WeakComponentInstance::new(&model.look_up(&target_moniker.to_partial()).await?);
+            let target = WeakComponentInstance::new(&model.look_up(&target_moniker).await?);
             Ok(Some(Box::new(BinderCapabilityProvider::new(source, target))
                 as Box<dyn CapabilityProvider>))
         } else {
@@ -151,7 +150,7 @@ impl Hook for BinderCapabilityHost {
             *capability_provider = self
                 .on_scoped_framework_capability_routed_async(
                     component.clone(),
-                    target_moniker.clone(),
+                    target_moniker.to_partial().clone(),
                     &capability,
                     capability_provider.take(),
                 )

src/sys/component_manager/src/collection.rs

@@ -15,7 +15,7 @@ use {
     },
     async_trait::async_trait,
     cm_rust::CapabilityTypeName,
-    moniker::{AbsoluteMoniker, AbsoluteMonikerBase, ExtendedMoniker},
+    moniker::{AbsoluteMonikerBase, ExtendedMoniker, PartialAbsoluteMoniker},
     routing::capability_source::{AggregateCapability, AggregateCapabilityProvider},
     std::sync::{Arc, Weak},
 };
@@ -42,16 +42,15 @@ impl CollectionCapabilityHost {
     async fn on_collection_capability_routed_async(
         self: Arc<Self>,
         source: WeakComponentInstance,
-        target_moniker: AbsoluteMoniker,
+        target_moniker: PartialAbsoluteMoniker,
         aggregate_capability_provider: Box<dyn AggregateCapabilityProvider<ComponentInstance>>,
         capability: &AggregateCapability,
         capability_provider: Option<Box<dyn CapabilityProvider>>,
     ) -> Result<Option<Box<dyn CapabilityProvider>>, ModelError> {
         // If some other capability has already been installed, then there's nothing to do here.
         if capability_provider.is_none() && capability.type_name() == CapabilityTypeName::Service {
             let model = self.model.upgrade().ok_or(ModelError::ModelNotAvailable)?;
-            let target =
-                WeakComponentInstance::new(&model.look_up(&target_moniker.to_partial()).await?);
+            let target = WeakComponentInstance::new(&model.look_up(&target_moniker).await?);
 
             Ok(Some(Box::new(
                 CollectionServiceDirectoryProvider::create(
@@ -91,7 +90,7 @@ impl Hook for CollectionCapabilityHost {
             *capability_provider = self
                 .on_collection_capability_routed_async(
                     component.clone(),
-                    target_moniker.clone(),
+                    target_moniker.to_partial().clone(),
                     aggregate_capability_provider.clone_boxed(),
                     &capability,
                     capability_provider.take(),

src/sys/component_manager/src/model/hub.rs

@@ -623,7 +623,6 @@ impl Hub {
     /// provide a hub directory.
     async fn on_capability_routed_async(
         self: Arc<Self>,
-        _target_moniker: &AbsoluteMoniker,
         source: CapabilitySource,
         capability_provider: Arc<Mutex<Option<Box<dyn CapabilityProvider>>>>,
     ) -> Result<(), ModelError> {
@@ -665,12 +664,8 @@ impl Hook for Hub {
             .unwrap_instance_moniker_or(ModelError::UnexpectedComponentManagerMoniker)?;
         match &event.result {
             Ok(EventPayload::CapabilityRouted { source, capability_provider }) => {
-                self.on_capability_routed_async(
-                    target_moniker,
-                    source.clone(),
-                    capability_provider.clone(),
-                )
-                .await?;
+                self.on_capability_routed_async(source.clone(), capability_provider.clone())
+                    .await?;
             }
             Ok(EventPayload::Purged) => {
                 self.on_purged_async(target_moniker).await?;