Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

mojo/services/media/common/cpp/circular_buffer_media_pipe_adapter.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_SERVICES_MEDIA_COMMON_CPP_CIRCULAR_BUFFER_MEDIA_PIPE_ADAPTER_H_
 #define MOJO_SERVICES_MEDIA_COMMON_CPP_CIRCULAR_BUFFER_MEDIA_PIPE_ADAPTER_H_
 
 #include <atomic>
 #include <deque>
 #include <functional>
 #include <limits>
 
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/services/media/common/interfaces/media_common.mojom.h"
 #include "mojo/services/media/common/interfaces/media_transport.mojom.h"
 
 namespace mojo {
 namespace media {
 
 // A class to help producers of media with the bookkeeping involved in using the
-// shared buffer provided by a MediaConsumer mojo interface in a circular buffer
-// fashion.
+// shared buffer provided by a MediaPacketConsumer mojo interface in a circular
+// buffer fashion.
 //
 class CircularBufferMediaPipeAdapter {
  public:
   class MappedPacket {
    public:
     static constexpr size_t kMaxRegions = 2;
     MappedPacket();
     ~MappedPacket();
 
     const MediaPacketPtr& packet() const { return packet_; }
@@ skipping 32 matching lines @@
    * entered into a fatal, unrecoverable state.
    *
    * @param state The current state of the adapter.  If the state is anything
    * but MediaResult::OK, the pipe is in a fatal, unrecoverable error state.
    */
   using SignalCbk = std::function<void(MediaResult state)>;
 
   /**
    * Constructor
    *
-   * Create an adapter which will take ownership of the provided MediaConsumer
-   * interface and assist in the process of generating MediaPackets and
-   * marshalling them to the other side of the MediaConsumer.
+   * Create an adapter which will take ownership of the provided
+   * MediaPacketConsumer interface and assist in the process of generating
+   * MediaPackets and marshalling them to the other side of the
+   * MediaPacketConsumer.
    *
-   * @param pipe A pointer to the MediaConsumer interface which will be used as
-   * the target for MediaPackets.
+   * @param pipe A pointer to the MediaPacketConsumer interface which will be
+   * used as the target for MediaPackets.
    */
-  explicit CircularBufferMediaPipeAdapter(MediaConsumerPtr pipe);
+  explicit CircularBufferMediaPipeAdapter(MediaPacketConsumerPtr pipe);
 
   /**
    * Destructor
    */
   ~CircularBufferMediaPipeAdapter();
 
   /**
    * Init
    *
    * Allocate a shared memory buffer of the specified size and begin the process
-   * of marshalling it to the other side of the MediaConsumer.
+   * of marshalling it to the other side of the MediaPacketConsumer.
    *
    * @param size The size in bytes of the shared memory buffer to allocate.
    */
   void Init(uint64_t size);
 
   /**
    * Set the signal callback for this media pipe adapter.  This callback will be
    * called when the adapter transitions from un-signalled to signalled and has
    * a valid callback, or when a valid callback is assigned (via a call to
    * Setllback) and the adapter is currently in the signalled state.
@@ skipping 77 matching lines @@
                                 MappedPacket* packet);
 
   /**
    * Send a previously created media packet across the pipe to the consumer.
    * @param [in] packet The pointer to the structure which describes the packet
    *                    to be sent.
    * @return A media result indicating the success or failure of the operation.
    */
   MediaResult SendMediaPacket(
       MappedPacket* packet,
-      const MediaConsumer::SendPacketCallback& cbk =
-        MediaConsumer::SendPacketCallback());
+      const MediaPacketConsumer::SendPacketCallback& cbk =
+        MediaPacketConsumer::SendPacketCallback());
 
   /**
    * Cancel a packet previously created using CreateMediaPacket.
    * @note The packet canceled must not have been sent, and must be the most
    * recent non-canceled packet created using CreateMediaPacket.
    * @param [in] packet The pointer to the structure which describes the packet
    *                    to be canceled.
    * @return A media result indicating the success or failure of the operation.
    */
   MediaResult CancelMediaPacket(MappedPacket* packet);
 
   /**
    * Flush the media pipe.  Cancels all in flight payloads and resets the
    * internal bookkeeping.
    *
    * @note The media pipe will be un-signalled and unavailable for Create/Send
    * operations during the flush.
    */
   MediaResult Flush();
 
   uint64_t GetPending() const;
   uint64_t GetBufferSize() const;
   uint64_t AboveHiWater() const { return GetPending() >= hi_water_mark_; }
   uint64_t BelowLoWater() const { return GetPending() <  lo_water_mark_; }
 
  private:
   struct PacketState {
     PacketState(uint64_t post_consume_rd,
                 uint32_t seq_num,
-                const MediaConsumer::SendPacketCallback& cbk);
+                const MediaPacketConsumer::SendPacketCallback& cbk);
     ~PacketState();
 
     uint64_t post_consume_rd_;
     uint32_t seq_num_;
-    MediaConsumer::SendPacketCallback cbk_;
+    MediaPacketConsumer::SendPacketCallback cbk_;
   };
   using PacketStateQueue = std::deque<PacketState>;
 
-  void HandleSendPacket(uint32_t seq_num, MediaConsumer::SendResult result);
+  void HandleSendPacket(uint32_t seq_num,
+      MediaPacketConsumer::SendResult result);
   void HandleFlush();
   void HandleSignalCallback();
 
   void UpdateSignalled();
   void Fault(MediaResult reason);
   void Cleanup();
 
   bool Faulted() const {
     return (MediaResult::OK != internal_state_);
   }
 
   bool Busy() const {
     return flush_in_progress_;
   }
 
   // Pipe interface callbacks
-  MediaConsumerPtr pipe_;
-  MediaConsumer::FlushCallback pipe_flush_cbk_;
-  Closure                      signalled_callback_;
+  MediaPacketConsumerPtr pipe_;
+  MediaPacketConsumer::FlushCallback pipe_flush_cbk_;
+  Closure signalled_callback_;
 
   // A small helper which lets us nerf callbacks we may have directly scheduled
   // on the main run loop which may be in flight as we get destroyed.
   std::shared_ptr<CircularBufferMediaPipeAdapter*> thiz_;
 
   // State for managing signalled/un-signalled status and signal callbacks.
   SignalCbk signal_cbk_;
   bool      flush_in_progress_ = false;
   bool      fault_cbk_made_ = false;
   bool      cbk_scheduled_ = false;
@@ skipping 11 matching lines @@
   // Packet queue state
   std::atomic<uint32_t> flush_generation_;
   std::atomic<uint32_t> seq_num_gen_;
   PacketStateQueue in_flight_queue_;
 };
 
 }  // namespace media
 }  // namespace mojo
 
 #endif  // MOJO_SERVICES_MEDIA_COMMON_CPP_CIRCULAR_BUFFER_MEDIA_PIPE_ADAPTER_H_