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..a37900d8a10c4b13db4a4843647da0aef635d51e
--- /dev/null
+++ b/services/media/framework/ptr.h
@@ -0,0 +1,62 @@
+// 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.
+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>() {}
+
+  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(); }

[johngro, 2016/01/26 23:47:29]

Do we really want to sub-class std::unique_ptr to get this functionality? 
Mostly, this just allows us to say..

UniquePtr<ClassA> obj = make_unique<ClassA>(...);
UniquePtr<ClassA> cloned = obj.Clone();

Instead of...

UniquePtr<ClassA> cloned = obj->Clone();

It also provides an automatic null check and will produce a new NULL unique_ptr
if the cloned pointer is NULL.  I'm not sure I see the value in this (why is
someone trying to clone an object which is not there?), but if you really want
this behavior, you should be able to say something like...

template <typename T>
std::unique_ptr<T> SafeClone(const std::unique_ptr<T> obj) {
  return obj ? obj->Clone() : nullptr;
}

and the code above becomes

std::unique_ptr<ClassA> cloned = SafeClone(obj);

without needing to extend std::unique_ptr

[dalesat, 2016/01/28 18:49:16]

Yes, this is just to get rid of the null check. I've added a TODO to get rid of
it.

+};
+
+// shared_ptr with upcast to TBase.

[johngro, 2016/01/26 23:47:29]

Why do this? std::shared_ptr already has 3 static methods which handle static,
dynamic and const casting for you.  To do what you are doing with the overloaded
operator below, you can just do things like...

std::shared_ptr<MyDerived> derived = std::make_shared<MyDerived>();
std::shared_ptr<MyBase> base = std::static_pointer_cast<MyBase>(derived);
GiveBaseToSomeoneElse(base);

This is permitted for both up and down casting.  Clearly you need to know what
you are doing when down casting, since we don't use RTTI and cannot use dynamic
cast.

Also, if you are not going to give the pointer to someone else (who might retain
it), and you don't want to make a temp shared_ptr, you can just cast the
underlying pointer.  Obviously, you would only ever need to do this in a
down-cast scenario

void GiveBaseToSomeoneElse(const std::shared_ptr<MyBase>& base) {
  // Danger, we had better know that base is actually a MyDerived
  MyDerived* derived = static_cast<MyDerived*>(base.get());
  derived->MethodOnlyInMyDerived(...);
}

[dalesat, 2016/01/28 18:49:16]

I wasn't aware of static_pointer_cast. This class is really about making this
Engine method work:

  template<typename T, typename TBase>
  Part Add(SharedPtr<T, TBase> t) {
    DCHECK(t);
    return Add(CreateStage(std::shared_ptr<TBase>(t)));
  }

I tried the following, but the compiler couldn't infer TBase.

  template<typename T, typename TBase>
  Part Add(std::shared_ptr<T> t) {
    DCHECK(t);
    return Add(CreateStage(std::static_pointer_cast<TBase>(t)));
  }

I've added a TODO for getting rid of this, if possible. I want the compiler to
figure out TBase, because some code calls Engine::Add without knowing what TBase
is. If that's possible, I'm fine with getting rid of this class.

[johngro, 2016/02/01 22:38:16]

Acknowledged.

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