Revert of Use std::unique_ptr. (patchset #8 id:130001 of https://codereview.chromium.org/1780933003/ )

Reason for revert:
Another Android ambiguity due to implicit bool...

frameworks/base/core/jni/android/graphics/Utils.cpp:110:35: error: call of overloaded 'SkMemoryStream(SkAutoTUnref<SkData>&)' is ambiguous
     return new SkMemoryStream(data);

Original issue's description:
> Use std::unique_ptr.
>
> TBR=reed@google.com
>
> Committed: https://skia.googlesource.com/skia/+/20c1e3abfc681771f73eb19fde7284196e028940
>
> Committed: https://skia.googlesource.com/skia/+/3dd9ed37c24611af86f0fe374bd3698b63f09450

TBR=bungeman@google.com,mtklein@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1785353002

19 files changed, 525 insertions, 77 deletions

diff --git a/gyp/core.gypi b/gyp/core.gypi
index 50e7aadd09..548eeea928 100644
--- a/gyp/core.gypi
+++ b/gyp/core.gypi
@@ -419,6 +419,7 @@
         '<(skia_include_path)/private/SkTDict.h',
         '<(skia_include_path)/private/SkTSearch.h',
         '<(skia_include_path)/private/SkTLogic.h',
+        '<(skia_include_path)/private/SkUniquePtr.h',
         '<(skia_include_path)/private/SkWeakRefCnt.h',
 
         # Path ops
diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index 5e334395a9..f159e3b1b7 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -9,10 +9,9 @@
 #define SkRefCnt_DEFINED
 
 #include "../private/SkAtomics.h"
-#include "../private/SkTLogic.h"
+#include "../private/SkUniquePtr.h"
 #include "SkTypes.h"
 #include <functional>
-#include <memory>
 #include <utility>
 
 #define SK_SUPPORT_TRANSITION_TO_SP_INTERFACES
@@ -190,9 +189,9 @@ template <typename T> struct SkTUnref {
 /**
  *  Utility class that simply unref's its argument in the destructor.
  */
-template <typename T> class SkAutoTUnref : public std::unique_ptr<T, SkTUnref<T>> {
+template <typename T> class SkAutoTUnref : public skstd::unique_ptr<T, SkTUnref<T>> {
 public:
-    explicit SkAutoTUnref(T* obj = nullptr) : std::unique_ptr<T, SkTUnref<T>>(obj) {}
+    explicit SkAutoTUnref(T* obj = nullptr) : skstd::unique_ptr<T, SkTUnref<T>>(obj) {}
 
     T* detach() { return this->release(); }
     operator T*() const { return this->get(); }
diff --git a/include/gpu/gl/SkGLContext.h b/include/gpu/gl/SkGLContext.h
index fe41a606ef..ddf5dc080a 100644
--- a/include/gpu/gl/SkGLContext.h
+++ b/include/gpu/gl/SkGLContext.h
@@ -25,7 +25,7 @@ public:
 
     const GrGLInterface* gl() const { return fGL.get(); }
 
-    bool fenceSyncSupport() const { return fFenceSync != nullptr; }
+    bool fenceSyncSupport() const { return SkToBool(fFenceSync); }
 
     bool getMaxGpuFrameLag(int* maxFrameLag) const {
         if (!fFenceSync) {
diff --git a/include/private/SkOncePtr.h b/include/private/SkOncePtr.h
index 3c1ab634ee..261f9a7ef4 100644
--- a/include/private/SkOncePtr.h
+++ b/include/private/SkOncePtr.h
@@ -9,7 +9,7 @@
 #define SkOncePtr_DEFINED
 
 #include "../private/SkAtomics.h"
-#include <memory>
+#include "SkUniquePtr.h"
 
 template <typename T> class SkBaseOncePtr;
 
@@ -17,7 +17,7 @@ template <typename T> class SkBaseOncePtr;
 #define SK_DECLARE_STATIC_ONCE_PTR(type, name) namespace {} static SkBaseOncePtr<type> name;
 
 // Use this for a local or member pointer that's initialized exactly once when you call get().
-template <typename T, typename Delete = std::default_delete<T>>
+template <typename T, typename Delete = skstd::default_delete<T>>
 class SkOncePtr : SkNoncopyable {
 public:
     SkOncePtr() { sk_bzero(this, sizeof(*this)); }
@@ -42,7 +42,7 @@ private:
 
 // If you ask for SkOncePtr<T[]>, we'll clean up with delete[] by default.
 template <typename T>
-class SkOncePtr<T[]> : public SkOncePtr<T, std::default_delete<T[]>> {};
+class SkOncePtr<T[]> : public SkOncePtr<T, skstd::default_delete<T[]>> {};
 
 /* TODO(mtklein): in next CL
 typedef SkBaseOncePtr<void> SkOnceFlag;
diff --git a/include/private/SkTemplates.h b/include/private/SkTemplates.h
index e74f512623..e36910e814 100644
--- a/include/private/SkTemplates.h
+++ b/include/private/SkTemplates.h
@@ -13,8 +13,8 @@
 #include "SkMath.h"
 #include "SkTLogic.h"
 #include "SkTypes.h"
+#include "SkUniquePtr.h"
 #include <limits.h>
-#include <memory>
 #include <new>
 
 /** \file SkTemplates.h
@@ -58,9 +58,9 @@ template <typename R, typename T, R (*P)(T*)> struct SkFunctionWrapper {
     function.
 */
 template <typename T, void (*P)(T*)> class SkAutoTCallVProc
-    : public std::unique_ptr<T, SkFunctionWrapper<void, T, P>> {
+    : public skstd::unique_ptr<T, SkFunctionWrapper<void, T, P>> {
 public:
-    SkAutoTCallVProc(T* obj): std::unique_ptr<T, SkFunctionWrapper<void, T, P>>(obj) {}
+    SkAutoTCallVProc(T* obj): skstd::unique_ptr<T, SkFunctionWrapper<void, T, P>>(obj) {}
 
     operator T*() const { return this->get(); }
     T* detach() { return this->release(); }
@@ -75,9 +75,9 @@ reference is null when the destructor is called, we do not call the
 function.
 */
 template <typename T, int (*P)(T*)> class SkAutoTCallIProc
-    : public std::unique_ptr<T, SkFunctionWrapper<int, T, P>> {
+    : public skstd::unique_ptr<T, SkFunctionWrapper<int, T, P>> {
 public:
-    SkAutoTCallIProc(T* obj): std::unique_ptr<T, SkFunctionWrapper<int, T, P>>(obj) {}
+    SkAutoTCallIProc(T* obj): skstd::unique_ptr<T, SkFunctionWrapper<int, T, P>>(obj) {}
 
     operator T*() const { return this->get(); }
     T* detach() { return this->release(); }
@@ -93,18 +93,18 @@ public:
 
   The size of a SkAutoTDelete is small: sizeof(SkAutoTDelete<T>) == sizeof(T*)
 */
-template <typename T> class SkAutoTDelete : public std::unique_ptr<T> {
+template <typename T> class SkAutoTDelete : public skstd::unique_ptr<T> {
 public:
-    SkAutoTDelete(T* obj = NULL) : std::unique_ptr<T>(obj) {}
+    SkAutoTDelete(T* obj = NULL) : skstd::unique_ptr<T>(obj) {}
 
     operator T*() const { return this->get(); }
     void free() { this->reset(nullptr); }
     T* detach() { return this->release(); }
 };
 
-template <typename T> class SkAutoTDeleteArray : public std::unique_ptr<T[]> {
+template <typename T> class SkAutoTDeleteArray : public skstd::unique_ptr<T[]> {
 public:
-    SkAutoTDeleteArray(T array[]) : std::unique_ptr<T[]>(array) {}
+    SkAutoTDeleteArray(T array[]) : skstd::unique_ptr<T[]>(array) {}
 
     void free() { this->reset(nullptr); }
     T* detach() { return this->release(); }
diff --git a/include/private/SkUniquePtr.h b/include/private/SkUniquePtr.h
new file mode 100644
index 0000000000..b1097d51eb
--- /dev/null
+++ b/include/private/SkUniquePtr.h
@@ -0,0 +1,408 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkUniquePtr_DEFINED
+#define SkUniquePtr_DEFINED
+
+#include "SkTLogic.h"
+#include <cstddef>
+#include <utility>
+
+namespace skstd {
+
+template <typename T> struct default_delete {
+    /*constexpr*/ default_delete() /*noexcept*/ = default;
+
+    template <typename U, typename = enable_if_t<is_convertible<U*, T*>::value>>
+    default_delete(const default_delete<U>&) /*noexcept*/ {}
+
+    void operator()(T* obj) const {
+        static_assert(sizeof(T) > 0, "Deleting pointer to incomplete type!");
+        delete obj;
+    }
+};
+template <typename T> struct default_delete<T[]> {
+    /*constexpr*/ default_delete() /*noexcept*/ = default;
+
+    void operator()(T* obj) const {
+        static_assert(sizeof(T) > 0, "Deleting pointer to incomplete type!");
+        delete [] obj;
+    }
+};
+
+template <typename T, typename D = default_delete<T>> class unique_ptr {
+    // remove_reference_t<D>::pointer if that type exists, otherwise T*.
+    struct pointer_type_detector {
+        template <typename U> static typename U::pointer detector(typename U::pointer*);
+        template <typename U> static T* detector(...);
+        using type = decltype(detector<remove_reference_t<D>>(0));
+    };
+
+public:
+    using pointer = typename pointer_type_detector::type;
+    using element_type = T;
+    using deleter_type = D;
+
+private:
+    template <typename B, bool>
+    struct compressed_base : private B {
+        /*constexpr*/ compressed_base() : B() {}
+        /*constexpr*/ compressed_base(const B& b) : B(b) {}
+        /*constexpr*/ compressed_base(B&& b) : B(std::move(b)) {}
+        /*constexpr*/ B& get() /*noexcept*/ { return *this; }
+        /*constexpr*/ B const& get() const /*noexcept*/ { return *this; }
+        void swap(compressed_base&) /*noexcept*/ { }
+    };
+
+    template <typename B> struct compressed_base<B, false> {
+        B fb;
+        /*constexpr*/ compressed_base() : B() {}
+        /*constexpr*/ compressed_base(const B& b) : fb(b) {}
+        /*constexpr*/ compressed_base(B&& b) : fb(std::move(b)) {}
+        /*constexpr*/ B& get() /*noexcept*/ { return fb; }
+        /*constexpr*/ B const& get() const /*noexcept*/ { return fb; }
+        void swap(compressed_base& that) /*noexcept*/ { SkTSwap(fb, that.fB); }
+    };
+
+    // C++14 adds '&& !std::is_final<deleter_type>::value' to the bool condition.
+    // compressed_base_t exists and has this form to work around a bug in vs2013sp2-3
+    using compressed_base_t = compressed_base<deleter_type, std::is_empty<deleter_type>::value>;
+
+    struct compressed_data : private compressed_base_t {
+        pointer fPtr;
+        /*constexpr*/ compressed_data() : compressed_base_t(), fPtr() {}
+        /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
+            : compressed_base_t(d), fPtr(ptr) {}
+        template <typename U1, typename U2, typename = enable_if_t<
+            is_convertible<U1, pointer>::value && is_convertible<U2, deleter_type>::value
+        >> /*constexpr*/ compressed_data(U1&& ptr, U2&& d)
+            : compressed_base_t(std::forward<U2>(d)), fPtr(std::forward<U1>(ptr)) {}
+        /*constexpr*/ pointer& getPointer() /*noexcept*/ { return fPtr; }
+        /*constexpr*/ pointer const& getPointer() const /*noexcept*/ { return fPtr; }
+        /*constexpr*/ deleter_type& getDeleter() /*noexcept*/ {
+            return compressed_base_t::get();
+        }
+        /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
+            return compressed_base_t::get();
+        }
+        void swap(compressed_data& that) /*noexcept*/ {
+            compressed_base_t::swap(static_cast<compressed_base_t>(that));
+            SkTSwap(fPtr, that.fPtr);
+        }
+    };
+    compressed_data data;
+
+public:
+    /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
+    }
+
+    /*constexpr*/ unique_ptr(std::nullptr_t) /*noexcept*/ : unique_ptr() { }
+
+    explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
+    }
+
+    unique_ptr(pointer ptr,
+               conditional_t<std::is_reference<deleter_type>::value,
+                             deleter_type, const deleter_type&> d)
+    /*noexcept*/ : data(ptr, d)
+    {}
+
+    unique_ptr(pointer ptr, remove_reference_t<deleter_type>&& d) /*noexcept*/
+        : data(std::move(ptr), std::move(d))
+    {
+        static_assert(!std::is_reference<deleter_type>::value,
+            "Binding an rvalue reference deleter as an lvalue reference deleter is not allowed.");
+    }
+
+
+    unique_ptr(unique_ptr&& that) /*noexcept*/
+        : data(that.release(), std::forward<deleter_type>(that.get_deleter()))
+    {}
+
+    template <typename U, typename ThatD, typename = enable_if_t<
+        is_convertible<typename unique_ptr<U, ThatD>::pointer, pointer>::value &&
+        !std::is_array<U>::value &&
+        conditional_t<std::is_reference<D>::value,
+                      std::is_same<ThatD, D>,
+                      is_convertible<ThatD, D>>::value>>
+    unique_ptr(unique_ptr<U, ThatD>&& that) /*noexcept*/
+        : data(that.release(), std::forward<ThatD>(that.get_deleter()))
+    {}
+
+    ~unique_ptr() /*noexcept*/ {
+        pointer& ptr = data.getPointer();
+        if (ptr != nullptr) {
+            get_deleter()(ptr);
+        }
+        ptr = pointer();
+    }
+
+    unique_ptr& operator=(unique_ptr&& that) /*noexcept*/ {
+        reset(that.release());
+        get_deleter() = std::forward<deleter_type>(that.get_deleter());
+        return *this;
+    }
+
+    template <typename U, typename ThatD> enable_if_t<
+        is_convertible<typename unique_ptr<U, ThatD>::pointer, pointer>::value &&
+        !std::is_array<U>::value,
+    unique_ptr&> operator=(unique_ptr<U, ThatD>&& that) /*noexcept*/ {
+        reset(that.release());
+        get_deleter() = std::forward<ThatD>(that.get_deleter());
+        return *this;
+    }
+
+    unique_ptr& operator=(std::nullptr_t) /*noexcept*/ {
+        reset();
+        return *this;
+    }
+
+    add_lvalue_reference_t<element_type> operator*() const {
+        SkASSERT(get() != pointer());
+        return *get();
+    }
+
+    pointer operator->() const /*noexcept*/ {
+        SkASSERT(get() != pointer());
+        return get();
+    }
+
+    pointer get() const /*noexcept*/ {
+        return data.getPointer();
+    }
+
+    deleter_type& get_deleter() /*noexcept*/ {
+        return data.getDeleter();
+    }
+
+    const deleter_type& get_deleter() const /*noexcept*/ {
+        return data.getDeleter();
+    }
+
+    //explicit operator bool() const noexcept {
+    bool is_attached() const /*noexcept*/ {
+        return get() == pointer() ? false : true;
+    }
+
+    pointer release() /*noexcept*/ {
+        pointer ptr = get();
+        data.getPointer() = pointer();
+        return ptr;
+    }
+
+    void reset(pointer ptr = pointer()) /*noexcept*/ {
+        SkTSwap(data.getPointer(), ptr);
+        if (ptr != pointer()) {
+            get_deleter()(ptr);
+        }
+    }
+
+    void swap(unique_ptr& that) /*noexcept*/ {
+        SkTSwap(data, that.data);
+    }
+
+    unique_ptr(const unique_ptr&) = delete;
+    unique_ptr& operator=(const unique_ptr&) = delete;
+};
+
+template <typename T, typename D> class unique_ptr<T[], D> {
+    // remove_reference_t<D>::pointer if that type exists, otherwise T*.
+    struct pointer_type_detector {
+        template <typename U> static typename U::pointer detector(typename U::pointer*);
+        template <typename U> static T* detector(...);
+        using type = decltype(detector<remove_reference_t<D>>(0));
+    };
+
+public:
+    using pointer = typename pointer_type_detector::type;
+    using element_type = T;
+    using deleter_type = D;
+
+private:
+    template <typename B, bool> struct compressed_base : private B {
+        /*constexpr*/ compressed_base() : B() {}
+        /*constexpr*/ compressed_base(const B& b) : B(b) {}
+        /*constexpr*/ compressed_base(B&& b) : B(std::move(b)) {}
+        /*constexpr*/ B& get() /*noexcept*/ { return *this; }
+        /*constexpr*/ B const& get() const /*noexcept*/ { return *this; }
+        void swap(compressed_base&) /*noexcept*/ { }
+    };
+
+    template <typename B> struct compressed_base<B, false> {
+        B fb;
+        /*constexpr*/ compressed_base() : B() {}
+        /*constexpr*/ compressed_base(const B& b) : fb(b) {}
+        /*constexpr*/ compressed_base(B&& b) : fb(std::move(b)) {}
+        /*constexpr*/ B& get() /*noexcept*/ { return fb; }
+        /*constexpr*/ B const& get() const /*noexcept*/ { return fb; }
+        void swap(compressed_base& that) /*noexcept*/ { SkTSwap(fb, that.fB); }
+    };
+
+    // C++14 adds '&& !std::is_final<deleter_type>::value' to the bool condition.
+    // compressed_base_t exists and has this form to work around a bug in vs2013sp2-3
+    using compressed_base_t = compressed_base<deleter_type, std::is_empty<deleter_type>::value>;
+
+    struct compressed_data : private compressed_base_t {
+        pointer fPtr;
+        /*constexpr*/ compressed_data() : compressed_base_t(), fPtr() {}
+        /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
+            : compressed_base_t(d), fPtr(ptr) {}
+        template <typename U1, typename U2, typename = enable_if_t<
+            is_convertible<U1, pointer>::value && is_convertible<U2, deleter_type>::value
+        >> /*constexpr*/ compressed_data(U1&& ptr, U2&& d)
+            : compressed_base_t(std::forward<U2>(d)), fPtr(std::forward<U1>(ptr)) {}
+        /*constexpr*/ pointer& getPointer() /*noexcept*/ { return fPtr; }
+        /*constexpr*/ pointer const& getPointer() const /*noexcept*/ { return fPtr; }
+        /*constexpr*/ deleter_type& getDeleter() /*noexcept*/ {
+            return compressed_base_t::get();
+        }
+        /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
+            return compressed_base_t::get();
+        }
+        void swap(compressed_data& that) /*noexcept*/ {
+            compressed_base_t::swap(static_cast<compressed_base_t>(that));
+            SkTSwap(fPtr, that.fPtr);
+        }
+    };
+    compressed_data data;
+
+public:
+    /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
+    }
+
+    /*constexpr*/ unique_ptr(std::nullptr_t) /*noexcept*/ : unique_ptr() { }
+
+    explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
+        static_assert(!std::is_pointer<deleter_type>::value, "Deleter nullptr function pointer!");
+    }
+
+    unique_ptr(pointer ptr,
+               conditional_t<std::is_reference<deleter_type>::value,
+                             deleter_type, const deleter_type&> d)
+    /*noexcept*/ : data(ptr, d)
+    {}
+
+    unique_ptr(pointer ptr, remove_reference_t<deleter_type>&& d) /*noexcept*/
+        : data(std::move(ptr), std::move(d))
+    {
+        static_assert(!std::is_reference<deleter_type>::value,
+            "Binding an rvalue reference deleter as an lvalue reference deleter is not allowed.");
+    }
+
+    unique_ptr(unique_ptr&& that) /*noexcept*/
+        : data(that.release(), std::forward<deleter_type>(that.get_deleter()))
+    {}
+
+    ~unique_ptr() {
+        pointer& ptr = data.getPointer();
+        if (ptr != nullptr) {
+          get_deleter()(ptr);
+        }
+        ptr = pointer();
+    }
+
+    unique_ptr& operator=(unique_ptr&& that) /*noexcept*/ {
+        reset(that.release());
+        get_deleter() = std::forward<deleter_type>(that.get_deleter());
+        return *this;
+    }
+
+    unique_ptr& operator=(std::nullptr_t) /*noexcept*/ {
+        reset();
+        return *this;
+    }
+
+    add_lvalue_reference_t<element_type> operator[](size_t i) const {
+        SkASSERT(get() != pointer());
+        return get()[i];
+    }
+
+    pointer get() const /*noexcept*/ {
+        return data.getPointer();
+    }
+
+    deleter_type& get_deleter() /*noexcept*/ {
+        return data.getDeleter();
+    }
+
+    const deleter_type& get_deleter() const /*noexcept*/ {
+        return data.getDeleter();
+    }
+
+    //explicit operator bool() const noexcept {
+    bool is_attached() const /*noexcept*/ {
+        return get() == pointer() ? false : true;
+    }
+
+    pointer release() /*noexcept*/ {
+        pointer ptr = get();
+        data.getPointer() = pointer();
+        return ptr;
+    }
+
+    void reset(pointer ptr = pointer()) /*noexcept*/ {
+        SkTSwap(data.getPointer(), ptr);
+        if (ptr != pointer()) {
+            get_deleter()(ptr);
+        }
+    }
+
+    template <typename U> void reset(U*) = delete;
+
+    void swap(unique_ptr& that) /*noexcept*/ {
+        data.swap(that.data);
+    }
+
+    unique_ptr(const unique_ptr&) = delete;
+    unique_ptr& operator=(const unique_ptr&) = delete;
+};
+
+template <typename T, typename D>
+inline void swap(unique_ptr<T, D>& a, unique_ptr<T, D>& b) /*noexcept*/ {
+    a.swap(b);
+}
+
+template <typename T, typename D, typename U, typename ThatD>
+inline bool operator==(const unique_ptr<T, D>& a, const unique_ptr<U, ThatD>& b) {
+    return a.get() == b.get();
+}
+
+template <typename T, typename D>
+inline bool operator==(const unique_ptr<T, D>& a, std::nullptr_t) /*noexcept*/ {
+    //return !a;
+    return !a.is_attached();
+}
+
+template <typename T, typename D>
+inline bool operator==(std::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
+    //return !b;
+    return !b.is_attached();
+}
+
+template <typename T, typename D, typename U, typename ThatD>
+inline bool operator!=(const unique_ptr<T, D>& a, const unique_ptr<U, ThatD>& b) {
+    return a.get() != b.get();
+}
+
+template <typename T, typename D>
+inline bool operator!=(const unique_ptr<T, D>& a, std::nullptr_t) /*noexcept*/ {
+    //return (bool)a;
+    return a.is_attached();
+}
+
+template <typename T, typename D>
+inline bool operator!=(std::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
+    //return (bool)b;
+    return b.is_attached();
+}
+
+}  // namespace skstd
+
+#endif
diff --git a/src/core/SkAdvancedTypefaceMetrics.cpp b/src/core/SkAdvancedTypefaceMetrics.cpp
index 406a759696..56a557c343 100644
--- a/src/core/SkAdvancedTypefaceMetrics.cpp
+++ b/src/core/SkAdvancedTypefaceMetrics.cpp
@@ -68,9 +68,9 @@ void resetRange(SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* range,
     range->fAdvance.setCount(0);
 }
 
-template <typename Data, template<typename> class AutoTDelete>
+template <typename Data>
 SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* appendRange(
-        AutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<Data> >* nextSlot,
+        SkAutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<Data> >* nextSlot,
         int startId) {
     nextSlot->reset(new SkAdvancedTypefaceMetrics::AdvanceMetric<Data>);
     resetRange(nextSlot->get(), startId);
diff --git a/src/core/SkAdvancedTypefaceMetrics.h b/src/core/SkAdvancedTypefaceMetrics.h
index 5a2180fade..b2c9ac3142 100644
--- a/src/core/SkAdvancedTypefaceMetrics.h
+++ b/src/core/SkAdvancedTypefaceMetrics.h
@@ -16,35 +16,6 @@
 #include "SkTDArray.h"
 #include "SkTemplates.h"
 
-// Whatever std::unique_ptr Clank's using doesn't seem to work with AdvanceMetric's
-// style of forward-declaration.  Probably just a bug in an old libc++ / libstdc++.
-// For now, hack around it with our own smart pointer.  It'd be nice to clean up.
-template <typename T>
-class SkHackyAutoTDelete : SkNoncopyable {
-public:
-    explicit SkHackyAutoTDelete(T* ptr = nullptr) : fPtr(ptr) {}
-    ~SkHackyAutoTDelete() { delete fPtr; }
-
-    T*        get() const { return fPtr; }
-    T* operator->() const { return fPtr; }
-
-    void reset(T* ptr) {
-        if (ptr != fPtr) {
-            delete fPtr;
-            fPtr = ptr;
-        }
-    }
-    void free() { this->reset(nullptr); }
-    T* detach() {
-        T* ptr = fPtr;
-        fPtr = nullptr;
-        return ptr;
-    }
-
-private:
-    T* fPtr;
-};
-
 /** \class SkAdvancedTypefaceMetrics
 
     The SkAdvancedTypefaceMetrics class is used by the PDF backend to correctly
@@ -126,7 +97,7 @@ public:
         uint16_t fStartId;
         uint16_t fEndId;
         SkTDArray<Data> fAdvance;
-        SkHackyAutoTDelete<AdvanceMetric<Data> > fNext;
+        SkAutoTDelete<AdvanceMetric<Data> > fNext;
     };
 
     struct VerticalMetric {
@@ -159,9 +130,9 @@ template <typename Data>
 void resetRange(SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* range,
                        int startId);
 
-template <typename Data, template<typename> class AutoTDelete>
+template <typename Data>
 SkAdvancedTypefaceMetrics::AdvanceMetric<Data>* appendRange(
-        AutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<Data> >* nextSlot,
+        SkAutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<Data> >* nextSlot,
         int startId);
 
 template <typename Data>
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index 8d6bae6992..2c49530e7c 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -272,7 +272,7 @@ private:
     AuxProcRec*            fAuxProcList;
 };
 
-class SkAutoGlyphCache : public std::unique_ptr<SkGlyphCache, SkGlyphCache::AttachCacheFunctor> {
+class SkAutoGlyphCache : public skstd::unique_ptr<SkGlyphCache, SkGlyphCache::AttachCacheFunctor> {
 public:
     /** deprecated: use get() */
     SkGlyphCache* getCache() const { return this->get(); }
@@ -294,7 +294,7 @@ public:
         : INHERITED(paint.detachCache(surfaceProps, fakeGamma, matrix))
     {}
 private:
-    using INHERITED = std::unique_ptr<SkGlyphCache, SkGlyphCache::AttachCacheFunctor>;
+    using INHERITED = skstd::unique_ptr<SkGlyphCache, SkGlyphCache::AttachCacheFunctor>;
 };
 
 class SkAutoGlyphCacheNoGamma : public SkAutoGlyphCache {
diff --git a/src/core/SkSharedMutex.h b/src/core/SkSharedMutex.h
index 21c9f46d64..840c2d36ad 100644
--- a/src/core/SkSharedMutex.h
+++ b/src/core/SkSharedMutex.h
@@ -14,7 +14,7 @@
 
 #ifdef SK_DEBUG
     #include "SkMutex.h"
-    #include <memory>
+    #include "SkUniquePtr.h"
 #endif  // SK_DEBUG
 
 // There are two shared lock implementations one debug the other is high performance. They implement
@@ -50,9 +50,9 @@ public:
 private:
 #ifdef SK_DEBUG
     class ThreadIDSet;
-    std::unique_ptr<ThreadIDSet> fCurrentShared;
-    std::unique_ptr<ThreadIDSet> fWaitingExclusive;
-    std::unique_ptr<ThreadIDSet> fWaitingShared;
+    skstd::unique_ptr<ThreadIDSet> fCurrentShared;
+    skstd::unique_ptr<ThreadIDSet> fWaitingExclusive;
+    skstd::unique_ptr<ThreadIDSet> fWaitingShared;
     int fSharedQueueSelect{0};
     mutable SkMutex fMu;
     SkSemaphore fSharedQueue[2];
diff --git a/src/gpu/GrLayerAtlas.cpp b/src/gpu/GrLayerAtlas.cpp
index c1f8732b35..df8215a607 100644
--- a/src/gpu/GrLayerAtlas.cpp
+++ b/src/gpu/GrLayerAtlas.cpp
@@ -12,7 +12,7 @@
 #include "GrTextureProvider.h"
 
 ///////////////////////////////////////////////////////////////////////////////
-GrLayerAtlas::Plot::Plot()
+GrLayerAtlas::Plot::Plot() 
     : fID(-1)
     , fRects(nullptr) {
     fOffset.set(0, 0);
@@ -54,7 +54,7 @@ bool GrLayerAtlas::reattachBackingTexture() {
     SkASSERT(!fTexture);
 
     fTexture.reset(fTexProvider->findAndRefTextureByUniqueKey(get_layer_atlas_key()));
-    return fTexture != nullptr;
+    return SkToBool(fTexture);
 }
 
 void GrLayerAtlas::createBackingTexture() {
@@ -71,7 +71,7 @@ void GrLayerAtlas::createBackingTexture() {
     fTexture->resourcePriv().setUniqueKey(get_layer_atlas_key());
 }
 
-GrLayerAtlas::GrLayerAtlas(GrTextureProvider* texProvider, GrPixelConfig config,
+GrLayerAtlas::GrLayerAtlas(GrTextureProvider* texProvider, GrPixelConfig config, 
                            GrSurfaceFlags flags,
                            const SkISize& backingTextureSize,
                            int numPlotsX, int numPlotsY) {
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index 661f22512d..ab9025d316 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -329,7 +329,7 @@ class GrStencilAndCoverTextContext::FallbackBlobBuilder {
 public:
     FallbackBlobBuilder() : fBuffIdx(0), fCount(0) {}
 
-    bool isInitialized() const { return fBuilder != nullptr; }
+    bool isInitialized() const { return SkToBool(fBuilder); }
 
     void init(const SkPaint& font, SkScalar textRatio);
 
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 57b5269423..744d42d25e 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -1533,10 +1533,10 @@ sk_sp<SkPDFArray> SkPDFDevice::copyMediaBox() const {
     return mediaBox;
 }
 
-std::unique_ptr<SkStreamAsset> SkPDFDevice::content() const {
+skstd::unique_ptr<SkStreamAsset> SkPDFDevice::content() const {
     SkDynamicMemoryWStream buffer;
     this->writeContent(&buffer);
-    return std::unique_ptr<SkStreamAsset>(
+    return skstd::unique_ptr<SkStreamAsset>(
             buffer.bytesWritten() > 0
             ? buffer.detachAsStream()
             : new SkMemoryStream);
diff --git a/src/pdf/SkPDFDevice.h b/src/pdf/SkPDFDevice.h
index b214839f5a..b1345a8e3f 100644
--- a/src/pdf/SkPDFDevice.h
+++ b/src/pdf/SkPDFDevice.h
@@ -168,7 +168,7 @@ public:
 
     /** Returns a SkStream with the page contents.
      */
-    std::unique_ptr<SkStreamAsset> content() const;
+    skstd::unique_ptr<SkStreamAsset> content() const;
 
     /** Writes the page contents to the stream. */
     void writeContent(SkWStream*) const;
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index f01c7d7cc5..9230507662 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -25,7 +25,7 @@
 #include "SkString.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
-#include <memory>
+#include "SkUniquePtr.h"
 
 #if defined(SK_CAN_USE_DLOPEN)
 #include <dlfcn.h>
@@ -802,7 +802,7 @@ SkScalerContext_FreeType::SkScalerContext_FreeType(SkTypeface* typeface, const S
 
     // load the font file
     using UnrefFTFace = SkFunctionWrapper<void, skstd::remove_pointer_t<FT_Face>, unref_ft_face>;
-    std::unique_ptr<skstd::remove_pointer_t<FT_Face>, UnrefFTFace> ftFace(ref_ft_face(typeface));
+    skstd::unique_ptr<skstd::remove_pointer_t<FT_Face>, UnrefFTFace> ftFace(ref_ft_face(typeface));
     if (nullptr == ftFace) {
         SkDEBUGF(("Could not create FT_Face.\n"));
         return;
@@ -891,7 +891,7 @@ SkScalerContext_FreeType::SkScalerContext_FreeType(SkTypeface* typeface, const S
     }
 
     using DoneFTSize = SkFunctionWrapper<FT_Error, skstd::remove_pointer_t<FT_Size>, FT_Done_Size>;
-    std::unique_ptr<skstd::remove_pointer_t<FT_Size>, DoneFTSize> ftSize([&ftFace]() -> FT_Size {
+    skstd::unique_ptr<skstd::remove_pointer_t<FT_Size>, DoneFTSize> ftSize([&ftFace]() -> FT_Size {
         FT_Size size;
         FT_Error err = FT_New_Size(ftFace.get(), &size);
         if (err != 0) {
diff --git a/tests/CPlusPlusEleven.cpp b/tests/CPlusPlusEleven.cpp
index 5fbd46429d..0cd2e937b2 100644
--- a/tests/CPlusPlusEleven.cpp
+++ b/tests/CPlusPlusEleven.cpp
@@ -28,3 +28,72 @@ DEF_TEST(CPlusPlusEleven_RvalueAndMove, r) {
     Moveable src1; Moveable dst1(std::move(src1));
     Moveable src2, dst2; dst2 = std::move(src2);
 }
+
+#define TOO_BIG "The unique_ptr was bigger than expected."
+#define WEIRD_SIZE "The unique_ptr was a different size than expected."
+
+DEF_TEST(CPlusPlusEleven_UniquePtr, r) {
+    struct SmallUniquePtr {
+        Moveable* p;
+    };
+    struct BigUniquePtr {
+        void(*d)(Moveable*);
+        Moveable* p;
+    };
+
+    static_assert(sizeof(skstd::unique_ptr<Moveable>) == sizeof(SmallUniquePtr), TOO_BIG);
+    static_assert(sizeof(skstd::unique_ptr<Moveable[]>) == sizeof(SmallUniquePtr), TOO_BIG);
+
+    using proc = void(*)(Moveable*);
+    static_assert(sizeof(skstd::unique_ptr<Moveable, proc>) == sizeof(BigUniquePtr), WEIRD_SIZE);
+    static_assert(sizeof(skstd::unique_ptr<Moveable[], proc>) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+    {
+        skstd::unique_ptr<Moveable, void(*)(Moveable*)> u(nullptr, deleter<Moveable>);
+        static_assert(sizeof(u) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(BigUniquePtr), WEIRD_SIZE);
+    }
+
+    {
+        skstd::unique_ptr<Moveable, void(*)(Moveable*)> u(nullptr, [](Moveable* m){ deleter(m); });
+        static_assert(sizeof(u) == sizeof(BigUniquePtr), WEIRD_SIZE);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(BigUniquePtr), WEIRD_SIZE);
+    }
+
+    {
+        auto d = [](Moveable* m){ deleter(m); };
+        skstd::unique_ptr<Moveable, decltype(d)> u(nullptr, d);
+        static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+    }
+
+    {
+        skstd::unique_ptr<Moveable, Deleter<Moveable>> u(nullptr, Deleter<Moveable>());
+        static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+    }
+
+    {
+        skstd::unique_ptr<Moveable, Deleter<Moveable>> u(new Moveable(), Deleter<Moveable>());
+        static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+    }
+
+    {
+        skstd::unique_ptr<const void, Deleter<const void>> u(new Moveable(), Deleter<const void>());
+        static_assert(sizeof(u) == sizeof(SmallUniquePtr), TOO_BIG);
+
+        auto u2 = std::move(u);
+        static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
+    }
+}
diff --git a/tests/ClearTest.cpp b/tests/ClearTest.cpp
index 25fcf85849..df152089fb 100644
--- a/tests/ClearTest.cpp
+++ b/tests/ClearTest.cpp
@@ -62,7 +62,7 @@ static bool reset_dc(SkAutoTUnref<GrDrawContext>* dc, SkAutoTUnref<GrSurface>* r
     GrRenderTarget* rt = (*rtKeepAlive)->asRenderTarget();
     SkASSERT(rt->getUniqueID() != oldID);
     dc->reset(context->drawContext(rt));
-    return *dc != nullptr;
+    return SkToBool(*dc);
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ClearBatch, reporter, context) {
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index a33deeb218..448e079958 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -1409,7 +1409,7 @@ DEF_TEST(Picture_preserveCullRect, r) {
     SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
     SkAutoTUnref<SkPicture> deserializedPicture(SkPicture::CreateFromStream(rstream));
 
-    REPORTER_ASSERT(r, deserializedPicture != nullptr);
+    REPORTER_ASSERT(r, SkToBool(deserializedPicture));
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().top() == 2);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().right() == 3);
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 784ae7e94d..c715b2efcc 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -136,7 +136,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
                     resourceProvider->attachStencilAttachment(bigRT->asRenderTarget()));
 
     if (context->caps()->maxSampleCount() >= 4) {
-        // An RT with a different sample count should not share.
+        // An RT with a different sample count should not share. 
         GrSurfaceDesc smallMSAADesc = smallDesc;
         smallMSAADesc.fSampleCnt = 4;
         SkAutoTUnref<GrTexture> smallMSAART0(cache->createTexture(smallMSAADesc, SkBudgeted::kNo));
@@ -216,8 +216,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, cont
     SkAutoTUnref<GrTexture> adopted(context->textureProvider()->wrapBackendTexture(
                                     desc, kAdopt_GrWrapOwnership));
 
-    REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
-    if (!borrowed || !adopted) {
+    REPORTER_ASSERT(reporter, SkToBool(borrowed) && SkToBool(adopted));
+    if (!SkToBool(borrowed) || !SkToBool(adopted)) {
         return;
     }
 
@@ -242,7 +242,7 @@ class TestResource : public GrGpuResource {
     enum ScratchConstructor { kScratchConstructor };
 public:
     static const size_t kDefaultSize = 100;
-
+    
     /** Property that distinctly categorizes the resource.
      * For example, textures have width, height, ... */
     enum SimulatedProperty { kA_SimulatedProperty, kB_SimulatedProperty };
@@ -590,7 +590,7 @@ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
         REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
 
         if (0 == i) {
-            // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try
+            // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try 
             // the above tests again.
             resource->resourcePriv().makeUnbudgeted();
         } else {
@@ -784,11 +784,11 @@ static void test_duplicate_unique_key(skiatest::Reporter* reporter) {
 
     GrUniqueKey key;
     make_unique_key<0>(&key, 0);
-
+    
     // Create two resources that we will attempt to register with the same unique key.
     TestResource* a = new TestResource(context->getGpu());
     a->setSize(11);
-
+    
     // Set key on resource a.
     a->resourcePriv().setUniqueKey(key);
     REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
@@ -882,7 +882,7 @@ static void test_purge_invalidated(skiatest::Reporter* reporter) {
     make_unique_key<0>(&key1, 1);
     make_unique_key<0>(&key2, 2);
     make_unique_key<0>(&key3, 3);
-
+    
     // Add three resources to the cache. Only c is usable as scratch.
     TestResource* a = new TestResource(context->getGpu());
     TestResource* b = new TestResource(context->getGpu());