Change who allocated the MediaPipe's shared buffer.

mojo/services/media/common/interfaces/media_pipe.mojom

 // 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.
 
 [DartPackage="mojo_services"]
 module mojo.media;
 
 import "mojo/services/media/common/interfaces/media_common.mojom";
 
 // MediaPacketRegion
@@ skipping 43 matching lines @@
   MediaPacketRegion payload;
   array<MediaPacketRegion>? extra_payload;
 
   // TODO(johngro): do we need to describe the MediaType of this payload, or is
   // its type implicit based on the channel over which it is being pushed?
 
   // TODO(johngro): how do we attach per-packet media specific metadata to this
   // packet?
 };
 
-// MediaPipeState
-//
-// A small structure used by the user of a media pipe to fetch the shared buffer
-// used by the media pipe to move bulk data.
-//
-// TODO(johngro): Right now, the only real purpose for this struture is to
-// bundle the size of the buffer with the buffer handle itself.  When buffer
-// handles can have their properties queried directly, it can go away.  See
-// domokit/mojo issue #501
-struct MediaPipeState {
-  const uint64 kMaxPayloadLen = 0x3FFFFFFFFFFFFFFF;
-
-  handle<shared_buffer> payload_buffer;
-
-  // TODO(johngro) : Why do I have to send this?  Why can't I just query the
-  // shared_buffer handle for its length?
-  uint64 payload_buffer_len;
-};
-
 // MediaPipe
 //
 // An interface exposed by consumers of media which provides the means for
 // producers to send media to consumers.  A pipe logically consists of a shared
 // memory region, and an ordered queue of MediaPackets.  Users obtain access to
 // the shared buffer via the GetState method.  They may then send packet to the
 // other side of the pipe using the SendPacket method and be informed about when
 // the media has been consumed via the SendPacket callback they provide.
 // Finally, the pipeline may be flushed using the Flush method.
 interface MediaPipe {
+  const uint64 kMaxBufferLen = 0x3FFFFFFFFFFFFFFF;
+
   // An enumeration used to indicate the ultimate fate of packets sent across
   // the pipe using the SendPacket method.
   enum SendResult {
     CONSUMED,  // Media was completely consumed.
     FLUSHED,   // Some or all of the media was flushed before being consumed.
   };
 
-  // Request that a reference to the pipe's state be sent to the caller via
-  // callback.
-  GetState() => (MediaPipeState state);
+  // Sets the shared buffer in which sent Packet payloads will be located.
+  SetBuffer(handle<shared_buffer> buffer, uint64 size);
 
   // Place a media packet into the pipeline to be consumed.  When the consumer
   // is finished with the packet, it will invoke the supplied callback to
   // indicate that the region of the shared buffer indicated by the MediaPacket
   // object is now available for new data.  In addition, a SendResult will be
   // providid indicating whether or not the packet was consumed or flushed.
   SendPacket(MediaPacket packet) => (SendResult result);
 
   // Flush the pipe, discarding all queued packets in order (from front to back)
   // as we go.  When the flush operation is complete, the provided callback will
   // be invoked to indicate that the consumer end of the pipe has finished
   // flushing and that the pipeline is now empty.
   Flush() => ();
 };