Motown in-proc streaming framework used to implement media services.

services/media/framework/models/active_sink.h

+// Copyright 2016 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_MEDIA_MODELS_ACTIVE_SINK_H_
+#define MOJO_MEDIA_MODELS_ACTIVE_SINK_H_
+
+#include <memory>
+
+#include "services/media/framework/allocator.h"
+#include "services/media/framework/models/demand.h"
+#include "services/media/framework/packet.h"
+
+namespace mojo {
+namespace media {
+
+// Sink that consumes packets asynchronously.
+class ActiveSink {
+ public:
+  virtual ~ActiveSink() {}
+
+  // Indicates whether the sink must allocate.
+  virtual bool must_allocate() const = 0;
+
+  // The consumer's allocator. Can return nullptr, in which case the default
+  // allocator should be used.
+  virtual Allocator* allocator() = 0;

[johngro, 2016/01/26 01:32:39]

Is it OK for a user of an ActiveSink to use something other than the default
allocator if the ActiveSink instance returns nullptr?  IOW - does nullptr mean;
"You really should use Allocator::GetDefault, but using something else is OK
too."

If not, then why not make this return an Allocator& and provide a default base
class implementation which returns *Allocator::GetDefault().

If so, then why not keep the return type as an Allocator* and provide a base
impl which returns Allocator::GetDefault().  Subclasses could override in order
to provide a specific allocator instance, or to indicate that they really don't
care (nullptr) which allocator is used.

[dalesat, 2016/01/26 21:17:51]

Allocator assignment is handled during Prepare by Stage, StageInput and
StageOutput instances. The only code that calls this method, for example, is in
ActiveSinkStage. Enlisting the default allocator is only done in a couple of
places, so there's no benefit to supplying it here. We get maximum flexibility
when 'parts' don't do anything they don't have to. I think your suggestion would
be the right way to go if allocator logic were more distributed, but it's not.

[johngro, 2016/01/27 22:35:22]

Acknowledged.

+
+  // Registers a callback that signals demand asynchronously.
+  using DemandCallback = std::function<void(Demand demand)>;
+  virtual void RegisterDemandCallback(DemandCallback demand_callback) = 0;
+
+  // Initiates demand.
+  virtual void Prime() = 0;
+
+  // Supplies a packet to the sink.
+  virtual Demand SupplyPacket(PacketPtr packet) = 0;
+};
+
+typedef std::shared_ptr<ActiveSink> ActiveSinkPtr;
+
+}  // namespace media
+}  // namespace mojo
+
+#endif // MOJO_MEDIA_MODELS_ACTIVE_SINK_H_