Change who allocated the MediaPipe's shared buffer.

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_pipe.mojom.h"
 
@@ skipping 21 matching lines @@
     cbk_(cbk) {}
 CircularBufferMediaPipeAdapter::PacketState::~PacketState() { }
 
 CircularBufferMediaPipeAdapter::CircularBufferMediaPipeAdapter(
     MediaPipePtr pipe)
   : pipe_(pipe.Pass())
   , thiz_(new CircularBufferMediaPipeAdapter*(this)) {
   MOJO_DCHECK(pipe_);
   MOJO_DCHECK(RunLoop::current());
 
-  pipe_get_state_cbk_ = MediaPipe::GetStateCallback(
-  [this] (MediaPipeStatePtr state) {
-    HandleGetState(state.Pass());
-  });
-
   pipe_flush_cbk_ = MediaPipe::FlushCallback(
   [this] () {
     HandleFlush();
   });
 
   pipe_.set_connection_error_handler(
   [this]() {
     Fault(MediaResult::CONNECTION_LOST);
   });
 
   std::shared_ptr<CircularBufferMediaPipeAdapter*> thiz(thiz_);
   signalled_callback_ = Closure(
   [thiz] () {
     if (*thiz) {
       (*thiz)->HandleSignalCallback();
     }
   });
-
-
-  // Begin by getting a hold of the shared buffer from our pipe over which we
-  // will push data.
-  MOJO_DCHECK(get_state_in_progress_);
-  pipe_->GetState(pipe_get_state_cbk_);
 }
 
 CircularBufferMediaPipeAdapter::~CircularBufferMediaPipeAdapter() {
   *thiz_ = nullptr;
   Cleanup();
 }
 
+void CircularBufferMediaPipeAdapter::Init(uint64_t size) {
+  // Double Init?  Fault unless the user is asking us to set up a buffer of the
+  // same size.
+  if (buffer_handle_.is_valid()) {
+    if (buffer_size_ != size) {
+      Fault(MediaResult::BAD_STATE);
+    }
+    return;
+  }
+
+  // Make the buffer
+  MojoResult res = CreateSharedBuffer(nullptr, size, &buffer_handle_);
+  if (res != MOJO_RESULT_OK) {
+    MOJO_LOG(ERROR) << "Failed to allocate buffer of size " << size
+                    << " in " << __PRETTY_FUNCTION__
+                    << " (error " << res << ")";
+    Fault(MediaResult::INSUFFICIENT_RESOURCES);
+    return;
+  }
+
+  buffer_size_ = size;
+
+  // Map the buffer
+  //
+  // TODO(johngro) : We really only need write access to this buffer.
+  // Ideally, we could request that using flags, but there does not seem to be
+  // a way to do this right now.
+  res = MapBuffer(buffer_handle_.get(),
+                  0,
+                  buffer_size_,
+                  &buffer_,
+                  MOJO_MAP_BUFFER_FLAG_NONE);
+  if (res != MOJO_RESULT_OK) {
+    MOJO_LOG(ERROR) << "Failed to map buffer in " << __PRETTY_FUNCTION__
+                    << " (error " << res << ")";
+    Fault(MediaResult::UNKNOWN_ERROR);
+    return;
+  }
+
+  // Duplicate the buffer and send it to the other side of the pipe.
+  //
+  // TODO(johngro) : It would be nice if we could restrict this handle to be
+  // read-only.
+  ScopedSharedBufferHandle duplicated_handle;
+  res = DuplicateBuffer(buffer_handle_.get(), nullptr, &duplicated_handle);
+  if (res != MOJO_RESULT_OK) {
+    MOJO_LOG(ERROR) << "Failed to duplicate handle in " << __PRETTY_FUNCTION__
+                    << " (error " << res << ")";
+    Fault(MediaResult::UNKNOWN_ERROR);
+    return;
+  }
+
+  // TODO(johngro) : We should not have to send the buffer size, it should be an
+  // intrinsic property of the buffer itself and be query-able via the handle.
+  pipe_->SetBuffer(duplicated_handle.Pass(), buffer_size_);
+}
+
 void CircularBufferMediaPipeAdapter::SetSignalCallback(SignalCbk cbk) {
   bool schedule;
   signal_cbk_ = cbk;
   schedule = (signal_cbk_ != nullptr);
 
   // If the user supplied a non-null callback, make sure we schedule a
   // callback if we are currently signalled.
   if (schedule) {
     UpdateSignalled();
   }
@@ skipping 204 matching lines @@
   in_flight_queue_.clear();
   rd_ = wr_ = 0;
   flush_in_progress_ = true;
   flush_generation_++;
 
   pipe_->Flush(pipe_flush_cbk_);
 
   return MediaResult::OK;
 }
 
-void CircularBufferMediaPipeAdapter::HandleGetState(MediaPipeStatePtr state) {
-  MOJO_DCHECK(state);     // We must have a state structure.
-  MOJO_DCHECK(!buffer_);  // We must not have already mapped a buffer.
-  MOJO_DCHECK(get_state_in_progress_);  // We should be waiting for our cbk.
-
-  // Success or failure, we are no longer waiting for our get state callback.
-  get_state_in_progress_ = false;
-  rd_ = wr_ = 0;
-
-  // Double init?  How did that happen?
-  if (buffer_handle_.is_valid() || (nullptr != buffer_)) {
-    MOJO_LOG(ERROR) << "Double init during " << __PRETTY_FUNCTION__;
-    Fault(MediaResult::UNKNOWN_ERROR);
-    return;
-  }
-
-  // No shared buffer?  That's a fatal error.
-  if (!state->payload_buffer.is_valid()) {
-    MOJO_LOG(ERROR) << "Null payload buffer in " << __PRETTY_FUNCTION__;
-    Fault(MediaResult::UNKNOWN_ERROR);
-    return;
-  }
-
-  // stash our state
-  buffer_handle_ = state->payload_buffer.Pass();
-  buffer_size_   = state->payload_buffer_len;
-
-  // Sanity checks the buffer size.
-  if (!buffer_size_ || (buffer_size_ > MediaPipeState::kMaxPayloadLen)) {
-    MOJO_LOG(ERROR) << "Bad buffer size in " << __PRETTY_FUNCTION__
-               << " (" << buffer_size_ << ")";
-    Fault(MediaResult::BAD_STATE);
-    return;
-  }
-
-  // Map our buffer
-  //
-  // TODO(johngro) : We really only need write access to this buffer.
-  // Ideally, we could request that using flags, but there does not seem to be
-  // a way to do this right now.
-  MojoResult res;
-  res = MapBuffer(buffer_handle_.get(),
-                  0,
-                  buffer_size_,
-                  &buffer_,
-                  MOJO_MAP_BUFFER_FLAG_NONE);
-  if (res != MOJO_RESULT_OK) {
-    MOJO_LOG(ERROR) << "Failed to map buffer in " << __PRETTY_FUNCTION__
-               << " (error " << res << ")";
-    Fault(MediaResult::UNKNOWN_ERROR);
-    return;
-  }
-
-  // Init is complete, we may be signalled now.
-  UpdateSignalled();
-}
-
 void CircularBufferMediaPipeAdapter::HandleSendPacket(
     uint32_t seq_num,
     MediaPipe::SendResult result) {
   MediaPipe::SendPacketCallback cbk;
 
   do {
-    if (get_state_in_progress_) {
-      // If we are in the process of getting the initial state of the system,
-      // then something is seriously wrong.  The other end of this interface is
-      // sending us Send callbacks while we are in the process of initializing
-      // (something which should be impossible)
-      Fault(MediaResult::PROTOCOL_ERROR);
-      break;
-    }
-
     // 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;
     }
 
     uint64_t new_rd = in_flight_queue_.front().post_consume_rd_;
@@ skipping 154 matching lines @@
 uint64_t CircularBufferMediaPipeAdapter::GetBufferSize() const {
   if (nullptr == buffer_)
     return 0;
 
   MOJO_DCHECK(buffer_size_);
   return buffer_size_ - 1;
 }
 
 }  // namespace media
 }  // namespace mojo