Merge Android U (ab/10368041)tmp_amf_298295554

Bug: 291102124
Merged-In: I10c41adb8fe3e126cfa4ff2f49b15863fff379de
Change-Id: I66f7a6cccaafc173d3924dae62a736c6c53520c7

1 files changed, 62 insertions, 23 deletions

diff --git a/pw_rpc/public/pw_rpc/internal/fake_channel_output.h b/pw_rpc/public/pw_rpc/internal/fake_channel_output.h
index cef049d4f..b60f5c598 100644
--- a/pw_rpc/public/pw_rpc/internal/fake_channel_output.h
+++ b/pw_rpc/public/pw_rpc/internal/fake_channel_output.h
@@ -16,6 +16,7 @@
 #include <cstddef>
 #include <iterator>
 #include <limits>
+#include <mutex>
 
 #include "pw_bytes/span.h"
 #include "pw_containers/vector.h"
@@ -29,6 +30,16 @@
 #include "pw_sync/lock_annotations.h"
 
 namespace pw::rpc {
+namespace internal {
+
+// Forward declare for a friend statement.
+template <class, size_t, size_t, size_t>
+class ForwardingChannelOutput;
+
+}  // namespace internal
+}  // namespace pw::rpc
+
+namespace pw::rpc {
 
 class FakeServer;
 
@@ -44,7 +55,7 @@ class FakeChannelOutput : public ChannelOutput {
   FakeChannelOutput& operator=(FakeChannelOutput&&) = delete;
 
   Status last_status() const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     PW_ASSERT(total_response_packets_ > 0);
     return packets_.back().status();
   }
@@ -59,7 +70,7 @@ class FakeChannelOutput : public ChannelOutput {
   template <auto kMethod>
   PayloadsView payloads(uint32_t channel_id = Channel::kUnassignedChannelId)
       const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return PayloadsView(packets_,
                         MethodInfo<kMethod>::kType,
                         channel_id,
@@ -71,10 +82,33 @@ class FakeChannelOutput : public ChannelOutput {
                         uint32_t channel_id,
                         uint32_t service_id,
                         uint32_t method_id) const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return PayloadsView(packets_, type, channel_id, service_id, method_id);
   }
 
+  // Returns a number of the payloads seen for this RPC.
+  template <auto kMethod>
+  size_t total_payloads(uint32_t channel_id = Channel::kUnassignedChannelId)
+      const PW_LOCKS_EXCLUDED(mutex_) {
+    std::lock_guard lock(mutex_);
+    return PayloadsView(packets_,
+                        MethodInfo<kMethod>::kType,
+                        channel_id,
+                        MethodInfo<kMethod>::kServiceId,
+                        MethodInfo<kMethod>::kMethodId)
+        .size();
+  }
+
+  // Returns a number of the payloads seen for this RPC.
+  size_t total_payloads(MethodType type,
+                        uint32_t channel_id,
+                        uint32_t service_id,
+                        uint32_t method_id) const PW_LOCKS_EXCLUDED(mutex_) {
+    std::lock_guard lock(mutex_);
+    return PayloadsView(packets_, type, channel_id, service_id, method_id)
+        .size();
+  }
+
   // Returns a view of the final statuses seen for this RPC. Only relevant for
   // checking packets sent by a server.
   //
@@ -86,10 +120,10 @@ class FakeChannelOutput : public ChannelOutput {
   template <auto kMethod>
   StatusView completions(uint32_t channel_id = Channel::kUnassignedChannelId)
       const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return StatusView(packets_,
-                      internal::PacketType::RESPONSE,
-                      internal::PacketType::RESPONSE,
+                      internal::pwpb::PacketType::RESPONSE,
+                      internal::pwpb::PacketType::RESPONSE,
                       channel_id,
                       MethodInfo<kMethod>::kServiceId,
                       MethodInfo<kMethod>::kMethodId);
@@ -105,10 +139,10 @@ class FakeChannelOutput : public ChannelOutput {
   template <auto kMethod>
   StatusView errors(uint32_t channel_id = Channel::kUnassignedChannelId) const
       PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return StatusView(packets_,
-                      internal::PacketType::CLIENT_ERROR,
-                      internal::PacketType::SERVER_ERROR,
+                      internal::pwpb::PacketType::CLIENT_ERROR,
+                      internal::pwpb::PacketType::SERVER_ERROR,
                       channel_id,
                       MethodInfo<kMethod>::kServiceId,
                       MethodInfo<kMethod>::kMethodId);
@@ -120,12 +154,12 @@ class FakeChannelOutput : public ChannelOutput {
   size_t client_stream_end_packets(
       uint32_t channel_id = Channel::kUnassignedChannelId) const
       PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return internal::test::PacketsView(
                packets_,
                internal::test::PacketFilter(
-                   internal::PacketType::CLIENT_STREAM_END,
-                   internal::PacketType::CLIENT_STREAM_END,
+                   internal::pwpb::PacketType::CLIENT_STREAM_END,
+                   internal::pwpb::PacketType::CLIENT_STREAM_END,
                    channel_id,
                    MethodInfo<kMethod>::kServiceId,
                    MethodInfo<kMethod>::kMethodId))
@@ -135,19 +169,19 @@ class FakeChannelOutput : public ChannelOutput {
   // The maximum number of packets this FakeChannelOutput can store. Attempting
   // to store more packets than this is an error.
   size_t max_packets() const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return packets_.max_size();
   }
 
   // The total number of packets that have been sent.
   size_t total_packets() const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return packets_.size();
   }
 
   // Set to true if a RESPONSE packet is seen.
   bool done() const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     return total_response_packets_ > 0;
   }
 
@@ -157,7 +191,7 @@ class FakeChannelOutput : public ChannelOutput {
   // Returns `status` for all future Send calls. Enables packet processing if
   // `status` is OK.
   void set_send_status(Status status) PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     send_status_ = status;
     return_after_packet_count_ = status.ok() ? -1 : 0;
   }
@@ -165,7 +199,7 @@ class FakeChannelOutput : public ChannelOutput {
   // Returns `status` once after the specified positive number of packets.
   void set_send_status(Status status, int return_after_packet_count)
       PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     PW_ASSERT(!status.ok());
     PW_ASSERT(return_after_packet_count > 0);
     send_status_ = status;
@@ -181,7 +215,7 @@ class FakeChannelOutput : public ChannelOutput {
   // When equals 0, returns `send_status_` in all future calls,
   // When negative, ignores `send_status_` processes buffer.
   Status Send(ConstByteSpan buffer) final PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     const Status status = HandlePacket(buffer);
     if (on_send_ != nullptr) {
       on_send_(buffer, status);
@@ -192,7 +226,7 @@ class FakeChannelOutput : public ChannelOutput {
   // Gives access to the last received internal::Packet. This is hidden by the
   // raw/Nanopb implementations, since it gives access to an internal class.
   const Packet& last_packet() const PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     PW_ASSERT(!packets_.empty());
     return packets_.back();
   }
@@ -205,7 +239,7 @@ class FakeChannelOutput : public ChannelOutput {
   // deadlocks.
   void set_on_send(Function<void(ConstByteSpan, Status)>&& on_send)
       PW_LOCKS_EXCLUDED(mutex_) {
-    LockGuard lock(mutex_);
+    std::lock_guard lock(mutex_);
     on_send_ = std::move(on_send);
   }
 
@@ -215,10 +249,16 @@ class FakeChannelOutput : public ChannelOutput {
         packets_(packets),
         payloads_(payloads) {}
 
-  const Vector<Packet>& packets() const { return packets_; }
+  const Vector<Packet>& packets() const PW_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
+    return packets_;
+  }
+
+  RpcLock& mutex() const { return mutex_; }
 
  private:
   friend class rpc::FakeServer;
+  template <class, size_t, size_t, size_t>
+  friend class internal::ForwardingChannelOutput;
 
   Status HandlePacket(ConstByteSpan buffer) PW_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   void CopyPayloadToBuffer(Packet& packet) PW_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
@@ -239,8 +279,7 @@ template <size_t kMaxPackets, size_t kPayloadsBufferSizeBytes>
 class FakeChannelOutputBuffer : public FakeChannelOutput {
  protected:
   FakeChannelOutputBuffer()
-      : FakeChannelOutput(packets_array_, payloads_array_), payloads_array_ {}
-  {}
+      : FakeChannelOutput(packets_array_, payloads_array_), payloads_array_{} {}
 
   Vector<std::byte, kPayloadsBufferSizeBytes> payloads_array_;
   Vector<Packet, kMaxPackets> packets_array_;