Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

services/media/common/media_pipe_base.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 "base/logging.h"
 #include "services/media/common/media_pipe_base.h"
 
 namespace mojo {
 namespace media {
 
 MediaPipeBase::MediaPipeBase()
   : binding_(this) {
 }
 
 MediaPipeBase::~MediaPipeBase() {
 }
 
-MojoResult MediaPipeBase::Init(InterfaceRequest<MediaConsumer> request) {
+MojoResult MediaPipeBase::Init(InterfaceRequest<MediaPacketConsumer> request) {
   // Double init?
   if (IsInitialized()) {
     return MOJO_RESULT_ALREADY_EXISTS;
   }
 
   binding_.Bind(request.Pass());
   binding_.set_connection_error_handler([this]() -> void {
     Reset();
   });
   return MOJO_RESULT_OK;
 }
 
 bool MediaPipeBase::IsInitialized() const {
   return binding_.is_bound();
 }
 
 void MediaPipeBase::Reset() {
   if (binding_.is_bound()) {
     binding_.Close();
   }
   buffer_ = nullptr;
 }
 
 void MediaPipeBase::SetBuffer(ScopedSharedBufferHandle handle,
                               const SetBufferCallback& cbk) {
   DCHECK(handle.is_valid());
 
   // Double init?  Close the connection.
   if (buffer_) {
-    LOG(ERROR) << "Attempting to set a new buffer on a MediaConsumer which "
-                  "already has a buffer assigned. (size = "
+    LOG(ERROR) << "Attempting to set a new buffer on a MediaPacketConsumer "
+                  "which already has a buffer assigned. (size = "
                << buffer_->size()
                << ")";
     Reset();
     return;
   }
 
   // Query the buffer for its size.  If we fail to query the info, close the
   // connection.
   MojoResult res;
   MojoBufferInformation info;
   res = MojoGetBufferInformation(handle.get().value(), &info, sizeof(info));
   if (res != MOJO_RESULT_OK) {
     LOG(ERROR) << "Failed to query shared buffer info (res = " << res << ")";
     Reset();
     return;
   }
 
   // Invalid size?  Close the connection.
   uint64_t size = info.num_bytes;
-  if (!size || (size > MediaConsumer::kMaxBufferLen)) {
+  if (!size || (size > MediaPacketConsumer::kMaxBufferLen)) {
     LOG(ERROR) << "Invalid shared buffer size (size = " << size << ")";
     Reset();
     return;
   }
 
   // Failed to map the buffer?  Close the connection.
   buffer_ = MappedSharedBuffer::Create(handle.Pass(), size);
   if (!buffer_) {
     LOG(ERROR) << "Failed to map shared memory buffer (size = " << size << ")";
     Reset();
@@ skipping 76 matching lines @@
   }
 }
 
 MediaPipeBase::MediaPacketState::MediaPacketState(
     MediaPacketPtr packet,
     const MappedSharedBufferPtr& buffer,
     const SendPacketCallback& cbk)
   : packet_(packet.Pass()),
     buffer_(buffer),
     cbk_(cbk),
-    result_(MediaConsumer::SendResult::CONSUMED) {
+    result_(MediaPacketConsumer::SendResult::CONSUMED) {
   DCHECK(packet_);
   DCHECK(packet_->payload);
 }
 
 MediaPipeBase::MediaPacketState::~MediaPacketState() {
   cbk_.Run(result_);
 }
 
 void MediaPipeBase::MediaPacketState::SetResult(
-    MediaConsumer::SendResult result) {
-  MediaConsumer::SendResult tmp = MediaConsumer::SendResult::CONSUMED;
+    MediaPacketConsumer::SendResult result) {
+  MediaPacketConsumer::SendResult tmp =
+      MediaPacketConsumer::SendResult::CONSUMED;
   result_.compare_exchange_strong(tmp, result);
 }
 
 MediaPipeBase::MappedSharedBufferPtr MediaPipeBase::MappedSharedBuffer::Create(
     ScopedSharedBufferHandle handle,
     uint64_t size) {
   MappedSharedBufferPtr ret(new MappedSharedBuffer(handle.Pass(), size));
   return ret->base() ? ret : nullptr;
 }
 
@@ skipping 18 matching lines @@
   if (MOJO_RESULT_OK != res) {
     LOG(ERROR) << "Failed to map shared buffer of size " << size_
                << " (res " << res << ")";
     DCHECK(base_ == nullptr);
     handle_.reset();
   }
 }
 
 }  // namespace media
 }  // namespace mojo