Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

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

 // 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.
 
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/services/media/common/cpp/circular_buffer_media_pipe_adapter.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 {
 
 constexpr size_t CircularBufferMediaPipeAdapter::MappedPacket::kMaxRegions;
 CircularBufferMediaPipeAdapter::MappedPacket::MappedPacket() { }
 CircularBufferMediaPipeAdapter::MappedPacket::~MappedPacket() {
   // If packet_ is non-null, it means that someone created a MappedPacket using
   // CreateMediaPacket, but they never sent it, and never canceled it.
   //
   // TODO(johngro): Should we maintain a reference to our pipe adapter and just
   // auto cancel this packet if the user forgets?  This could be Very Bad if
   // they have created and forgotten about multiple packets.
   MOJO_DCHECK(packet_.is_null());
 }
 
 CircularBufferMediaPipeAdapter::PacketState::PacketState(
     uint64_t post_consume_rd,
     uint32_t seq_num,
-    const MediaConsumer::SendPacketCallback& cbk)
+    const MediaPacketConsumer::SendPacketCallback& cbk)
   : post_consume_rd_(post_consume_rd),
     seq_num_(seq_num),
     cbk_(cbk) {}
 CircularBufferMediaPipeAdapter::PacketState::~PacketState() { }
 
 CircularBufferMediaPipeAdapter::CircularBufferMediaPipeAdapter(
-    MediaConsumerPtr pipe)
+    MediaPacketConsumerPtr pipe)
   : pipe_(pipe.Pass())
   , thiz_(new CircularBufferMediaPipeAdapter*(this)) {
   MOJO_DCHECK(pipe_);
   MOJO_DCHECK(RunLoop::current());
 
-  pipe_flush_cbk_ = MediaConsumer::FlushCallback(
+  pipe_flush_cbk_ = MediaPacketConsumer::FlushCallback(
   [this] () {
     HandleFlush();
   });
 
   pipe_.set_connection_error_handler(
   [this]() {
     Fault(MediaResult::CONNECTION_LOST);
   });
 
   std::shared_ptr<CircularBufferMediaPipeAdapter*> thiz(thiz_);
@@ skipping 182 matching lines @@
 
   // now that we have moved the write pointer, we may be signalled again.
   // Need to re-evaluate.
   UpdateSignalled();
 
   return MediaResult::OK;
 }
 
 MediaResult CircularBufferMediaPipeAdapter::SendMediaPacket(
     MappedPacket* packet,
-    const MediaConsumer::SendPacketCallback& cbk) {
+    const MediaPacketConsumer::SendPacketCallback& cbk) {
   MOJO_DCHECK(packet && !packet->packet_.is_null());
   if (!packet || packet->packet_.is_null()) {
     return MediaResult::INVALID_ARGUMENT;
   }
 
   const MediaPacketPtr& p = packet->packet_;
   MOJO_DCHECK(!p->extra_payload.is_null());
   MOJO_DCHECK(p->extra_payload.size() <= 1u);
 
   uint64_t post_consume_rd = p->extra_payload.size()
@@ skipping 32 matching lines @@
 
   MOJO_DCHECK(post_consume_rd <= buffer_size_);
   if (post_consume_rd == buffer_size_)
     post_consume_rd = 0;
 
   uint32_t seq_num = seq_num_gen_++;
   in_flight_queue_.emplace_back(post_consume_rd, seq_num, cbk);
 
   pipe_->SendPacket(
       packet->packet_.Pass(),
-      [this, seq_num](MediaConsumer::SendResult result) {
+      [this, seq_num](MediaPacketConsumer::SendResult result) {
         HandleSendPacket(seq_num, result);
       });
 
   packet->Reset();
 
   return MediaResult::OK;
 }
 
 MediaResult CircularBufferMediaPipeAdapter::CancelMediaPacket(
     MappedPacket* packet) {
@@ skipping 28 matching lines @@
   flush_in_progress_ = true;
   flush_generation_++;
 
   pipe_->Flush(pipe_flush_cbk_);
 
   return MediaResult::OK;
 }
 
 void CircularBufferMediaPipeAdapter::HandleSendPacket(
     uint32_t seq_num,
-    MediaConsumer::SendResult result) {
-  MediaConsumer::SendPacketCallback cbk;
+    MediaPacketConsumer::SendResult result) {
+  MediaPacketConsumer::SendPacketCallback cbk;
 
   do {
     // There should be at least one element in the in-flight queue, and the
     // front of the queue's sequence number should match the sequence number of
     // the payload being returned to us.
     if (!in_flight_queue_.size() ||
         (in_flight_queue_.front().seq_num_ != seq_num)) {
       Fault(MediaResult::UNKNOWN_ERROR);
       break;
     }
@@ skipping 156 matching lines @@
 uint64_t CircularBufferMediaPipeAdapter::GetBufferSize() const {
   if (nullptr == buffer_)
     return 0;
 
   MOJO_DCHECK(buffer_size_);
   return buffer_size_ - 1;
 }
 
 }  // namespace media
 }  // namespace mojo