Change who allocated the MediaPipe's shared buffer.

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>
@@ skipping 52 matching lines @@
    * A callback definition, registered by users of the adapter.  The callback
    * will be called any time the adapter is in the signalled state, either
    * because there is room for more data in the pipe, or because the pipe has
    * 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 MediaPipe
+   * interface and assist in the process of generating MediaPackets and
+   * marshalling them to the other side of the MediaPipe.
+   *
+   * @param pipe A pointer to the MediaPipe interface which will be used as the
+   * target for MediaPackets.
+   */
   explicit CircularBufferMediaPipeAdapter(MediaPipePtr 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 MediaPipe.
+   *
+   * @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.
    *
    * Any callbacks in flight are guaranteed to be canceled or executed to
    * completion when SetCallback returns.
    *
    * It is the adapter's user's responsibility to manage the lifetime of the
    * callback and the adapter, and ensure that the callback is valid as long as
@@ skipping 111 matching lines @@
                 uint32_t seq_num,
                 const MediaPipe::SendPacketCallback& cbk);
     ~PacketState();
 
     uint64_t post_consume_rd_;
     uint32_t seq_num_;
     MediaPipe::SendPacketCallback cbk_;
   };
   using PacketStateQueue = std::deque<PacketState>;
 
-  void HandleGetState(MediaPipeStatePtr state);
   void HandleSendPacket(uint32_t seq_num, MediaPipe::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 (get_state_in_progress_ || flush_in_progress_);
+    return flush_in_progress_;
   }
 
   // Pipe interface callbacks
   MediaPipePtr pipe_;
-  MediaPipe::GetStateCallback pipe_get_state_cbk_;
   MediaPipe::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      get_state_in_progress_ = true;
   bool      flush_in_progress_ = false;
   bool      fault_cbk_made_ = false;
   bool      cbk_scheduled_ = false;
   uint64_t  hi_water_mark_ = 0u;
   uint64_t  lo_water_mark_ = 0u;
   bool      signalled_ = false;
 
   MediaResult internal_state_ = MediaResult::OK;
 
   ScopedSharedBufferHandle buffer_handle_;
   void*    buffer_ = nullptr;
-  uint64_t buffer_size_;
+  uint64_t buffer_size_ = 0;
   uint64_t rd_, wr_;
 
   // 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_