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

services/media/framework/ptr.h

Index: services/media/framework/ptr.h
diff --git a/services/media/framework/ptr.h b/services/media/framework/ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..824f1a73642b7f8eb9339549c0fa42b578f262ff
--- /dev/null
+++ b/services/media/framework/ptr.h
@@ -0,0 +1,64 @@
+// 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 SERVICES_MEDIA_FRAMEWORK_PTR_H_
+#define SERVICES_MEDIA_FRAMEWORK_PTR_H_
+
+#include <memory>
+
+namespace mojo {
+namespace media {
+
+// unique_ptr with Clone.
+// TODO(dalesat): Remove in favor of unique_ptr and a Clone template function.

[jeffbrown, 2016/02/02 05:35:48]

+1, get rid of this thing entirely

[dalesat, 2016/02/02 21:46:40]

Acknowledged.

+template<class T, class Deleter = std::default_delete<T>>
+class UniquePtr : public std::unique_ptr<T, Deleter> {
+ public:
+  UniquePtr() : std::unique_ptr<T, Deleter>() {}
+
+  UniquePtr(std::nullptr_t) : std::unique_ptr<T, Deleter>() {}

[jeffbrown, 2016/02/02 05:35:48]

All one-arg constructors should be explicit.

[dalesat, 2016/02/02 21:46:40]

True for std::nullptr_t as well? What I have here is consistent with
std::unique_ptr.

[jeffbrown, 2016/02/03 01:46:56]

Ahh, unique_ptr may be a special case to allow some nice syntax for smart
pointers.  Anyhow, you're going to delete this so it's moot.

+
+  explicit UniquePtr(T* ptr) : std::unique_ptr<T, Deleter>(ptr) {}
+
+  UniquePtr(UniquePtr&& other) :
+      std::unique_ptr<T, Deleter>(std::move(other)) {}
+
+  UniquePtr& operator=(std::nullptr_t) {
+    this->reset();
+    return *this;
+  }
+
+  UniquePtr& operator=(UniquePtr&& other) {
+    *static_cast<std::unique_ptr<T, Deleter>*>(this) = std::move(other);
+    return *this;
+  }
+
+  UniquePtr Clone() const { return *this ? this->get()->Clone() : UniquePtr(); }
+};
+
+// shared_ptr with upcast to TBase.
+// TODO(dalesat): Remove in favor of shared_ptr.
+template<class T, typename TBase>
+class SharedPtr : public std::shared_ptr<T> {
+ public:
+  SharedPtr() : std::shared_ptr<T>() {}
+
+  SharedPtr(std::nullptr_t) : std::shared_ptr<T>() {}
+
+  explicit SharedPtr(T* ptr) : std::shared_ptr<T>(ptr) {}
+
+  SharedPtr& operator=(std::nullptr_t) {
+    this->reset();
+    return *this;
+  }
+
+  operator std::shared_ptr<TBase>() const {

[jeffbrown, 2016/02/02 05:35:48]

Avoid conversion operators.

[dalesat, 2016/02/02 21:46:40]

This is used to solve a specific problem, namely how to engine->Add(part) and
have the right stage created. I think there may be some template magic involving
std::enable_if that will achieve this. The TODO above is there for this purpose.

+    return std::shared_ptr<TBase>(*this, this->get());
+  }
+};
+
+}  // namespace media
+}  // namespace mojo
+
+#endif // SERVICES_MEDIA_FRAMEWORK_PTR_H_