From 06189155d987db5c7e69015f6ea87c2168d6a065 Mon Sep 17 00:00:00 2001
From: mtklein <mtklein@chromium.org>
Date: Mon, 23 Nov 2015 09:12:31 -0800
Subject: skstd -> std for unique_ptr

TBR=reed@google.com
No public API changes.

BUG=skia:4564

Committed: https://skia.googlesource.com/skia/+/755c553c17b82bb5de3d9cc8d3b2a866ff9e9e50

CQ_EXTRA_TRYBOTS=client.skia.compile:Build-Mac10.9-Clang-x86_64-Release-CMake-Trybot,Build-Ubuntu-GCC-x86_64-Debug-CrOS_Link-Trybot

Review URL: https://codereview.chromium.org/1436033003
---
 include/core/SkRefCnt.h       |   6 +-
 include/core/SkTypes.h        |   6 +-
 include/private/SkOncePtr.h   |   6 +-
 include/private/SkTemplates.h |  18 +-
 include/private/SkUniquePtr.h | 396 ------------------------------------------
 5 files changed, 20 insertions(+), 412 deletions(-)
 delete mode 100644 include/private/SkUniquePtr.h

(limited to 'include')

diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index 0e8d857722..1033bccc88 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -9,8 +9,8 @@
 #define SkRefCnt_DEFINED
 
 #include "../private/SkAtomics.h"
-#include "../private/SkUniquePtr.h"
 #include "SkTypes.h"
+#include <memory>
 
 /** \class SkRefCntBase
 
@@ -185,9 +185,9 @@ template <typename T> struct SkTUnref {
 /**
  *  Utility class that simply unref's its argument in the destructor.
  */
-template <typename T> class SkAutoTUnref : public skstd::unique_ptr<T, SkTUnref<T>> {
+template <typename T> class SkAutoTUnref : public std::unique_ptr<T, SkTUnref<T>> {
 public:
-    explicit SkAutoTUnref(T* obj = nullptr) : skstd::unique_ptr<T, SkTUnref<T>>(obj) {}
+    explicit SkAutoTUnref(T* obj = nullptr) : std::unique_ptr<T, SkTUnref<T>>(obj) {}
 
     T* detach() { return this->release(); }
     operator T*() const { return this->get(); }
diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
index d9254acf5f..a722ef8d36 100644
--- a/include/core/SkTypes.h
+++ b/include/core/SkTypes.h
@@ -257,7 +257,11 @@ typedef uint8_t SkBool8;
 
 /** Returns 0 or 1 based on the condition
 */
-#define SkToBool(cond)  ((cond) != 0)
+#if defined(_MSC_VER)
+    #define SkToBool(cond)  (!!(cond))   // MSVC doesn't like a cast.
+#else
+    #define SkToBool(cond)  static_cast<bool>(cond)
+#endif
 
 #define SK_MaxS16   32767
 #define SK_MinS16   -32767
diff --git a/include/private/SkOncePtr.h b/include/private/SkOncePtr.h
index 261f9a7ef4..3c1ab634ee 100644
--- a/include/private/SkOncePtr.h
+++ b/include/private/SkOncePtr.h
@@ -9,7 +9,7 @@
 #define SkOncePtr_DEFINED
 
 #include "../private/SkAtomics.h"
-#include "SkUniquePtr.h"
+#include <memory>
 
 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 = skstd::default_delete<T>>
+template <typename T, typename Delete = std::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, skstd::default_delete<T[]>> {};
+class SkOncePtr<T[]> : public SkOncePtr<T, std::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 533cb264d1..db85fbc3dd 100644
--- a/include/private/SkTemplates.h
+++ b/include/private/SkTemplates.h
@@ -13,9 +13,9 @@
 #include "SkMath.h"
 #include "SkTLogic.h"
 #include "SkTypes.h"
-#include "SkUniquePtr.h"
 #include "SkUtility.h"
 #include <limits.h>
+#include <memory>
 #include <new>
 
 /** \file SkTemplates.h
@@ -59,9 +59,9 @@ template <typename R, typename T, R (*P)(T*)> struct SkFunctionWrapper {
     function.
 */
 template <typename T, void (*P)(T*)> class SkAutoTCallVProc
-    : public skstd::unique_ptr<T, SkFunctionWrapper<void, T, P>> {
+    : public std::unique_ptr<T, SkFunctionWrapper<void, T, P>> {
 public:
-    SkAutoTCallVProc(T* obj): skstd::unique_ptr<T, SkFunctionWrapper<void, T, P>>(obj) {}
+    SkAutoTCallVProc(T* obj): std::unique_ptr<T, SkFunctionWrapper<void, T, P>>(obj) {}
 
     operator T*() const { return this->get(); }
     T* detach() { return this->release(); }
@@ -76,9 +76,9 @@ reference is null when the destructor is called, we do not call the
 function.
 */
 template <typename T, int (*P)(T*)> class SkAutoTCallIProc
-    : public skstd::unique_ptr<T, SkFunctionWrapper<int, T, P>> {
+    : public std::unique_ptr<T, SkFunctionWrapper<int, T, P>> {
 public:
-    SkAutoTCallIProc(T* obj): skstd::unique_ptr<T, SkFunctionWrapper<int, T, P>>(obj) {}
+    SkAutoTCallIProc(T* obj): std::unique_ptr<T, SkFunctionWrapper<int, T, P>>(obj) {}
 
     operator T*() const { return this->get(); }
     T* detach() { return this->release(); }
@@ -94,18 +94,18 @@ public:
 
   The size of a SkAutoTDelete is small: sizeof(SkAutoTDelete<T>) == sizeof(T*)
 */
-template <typename T> class SkAutoTDelete : public skstd::unique_ptr<T> {
+template <typename T> class SkAutoTDelete : public std::unique_ptr<T> {
 public:
-    SkAutoTDelete(T* obj = NULL) : skstd::unique_ptr<T>(obj) {}
+    SkAutoTDelete(T* obj = NULL) : std::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 skstd::unique_ptr<T[]> {
+template <typename T> class SkAutoTDeleteArray : public std::unique_ptr<T[]> {
 public:
-    SkAutoTDeleteArray(T array[]) : skstd::unique_ptr<T[]>(array) {}
+    SkAutoTDeleteArray(T array[]) : std::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
deleted file mode 100644
index 5d6e722658..0000000000
--- a/include/private/SkUniquePtr.h
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * 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 "SkUtility.h"
-
-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 = is_empty<B>::value /*&& !is_final<B>::value*/>
-    struct compressed_base : private B {
-        /*constexpr*/ compressed_base() : B() {}
-        /*constexpr*/ compressed_base(const B& b) : B(b) {}
-        /*constexpr*/ compressed_base(const B&& b) : B(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(const B&& b) : fb(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); }
-    };
-
-    struct compressed_data : private compressed_base<deleter_type> {
-        pointer fPtr;
-        /*constexpr*/ compressed_data() : compressed_base<deleter_type>(), fPtr() {}
-        /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
-            : compressed_base<deleter_type>(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<deleter_type>(skstd::forward<U2>(d)), fPtr(skstd::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<deleter_type>::get();
-        }
-        /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
-            return compressed_base<deleter_type>::get();
-        }
-        void swap(compressed_data& that) /*noexcept*/ {
-            compressed_base<deleter_type>::swap(static_cast<compressed_base<deleter_type>>(that));
-            SkTSwap(fPtr, that.fPtr);
-        }
-    };
-    compressed_data data;
-
-public:
-    /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
-        static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
-    }
-
-    /*constexpr*/ unique_ptr(skstd::nullptr_t) /*noexcept*/ : unique_ptr() { }
-
-    explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
-        static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
-    }
-
-    unique_ptr(pointer ptr,
-               conditional_t<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(move(ptr), move(d))
-    {
-        static_assert(!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(), 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 &&
-        !is_array<U>::value &&
-        conditional_t<is_reference<D>::value, is_same<ThatD, D>, is_convertible<ThatD, D>>::value>>
-    unique_ptr(unique_ptr<U, ThatD>&& that) /*noexcept*/
-        : data(that.release(), 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() = 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 &&
-        !is_array<U>::value,
-    unique_ptr&> operator=(unique_ptr<U, ThatD>&& that) /*noexcept*/ {
-        reset(that.release());
-        get_deleter() = forward<ThatD>(that.get_deleter());
-        return *this;
-    }
-
-    unique_ptr& operator=(skstd::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 = is_empty<B>::value /*&& !is_final<B>::value*/>
-    struct compressed_base : private B {
-        /*constexpr*/ compressed_base() : B() {}
-        /*constexpr*/ compressed_base(const B& b) : B(b) {}
-        /*constexpr*/ compressed_base(const B&& b) : B(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(const B&& b) : fb(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); }
-    };
-
-    struct compressed_data : private compressed_base<deleter_type> {
-        pointer fPtr;
-        /*constexpr*/ compressed_data() : compressed_base<deleter_type>(), fPtr() {}
-        /*constexpr*/ compressed_data(const pointer& ptr, const deleter_type& d)
-            : compressed_base<deleter_type>(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<deleter_type>(skstd::forward<U2>(d)), fPtr(skstd::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<deleter_type>::get();
-        }
-        /*constexpr*/ deleter_type const& getDeleter() const /*noexcept*/ {
-            return compressed_base<deleter_type>::get();
-        }
-        void swap(compressed_data& that) /*noexcept*/ {
-            compressed_base<deleter_type>::swap(static_cast<compressed_base<deleter_type>>(that));
-            SkTSwap(fPtr, that.fPtr);
-        }
-    };
-    compressed_data data;
-
-public:
-    /*constexpr*/ unique_ptr() /*noexcept*/ : data() {
-        static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
-    }
-
-    /*constexpr*/ unique_ptr(skstd::nullptr_t) /*noexcept*/ : unique_ptr() { }
-
-    explicit unique_ptr(pointer ptr) /*noexcept*/ : data(ptr, deleter_type()) {
-        static_assert(!is_pointer<deleter_type>::value, "Deleter is nullptr function pointer!");
-    }
-
-    unique_ptr(pointer ptr,
-               conditional_t<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(move(ptr), move(d))
-    {
-        static_assert(!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(), 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() = forward<deleter_type>(that.get_deleter());
-        return *this;
-    }
-
-    unique_ptr& operator=(skstd::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, skstd::nullptr_t) /*noexcept*/ {
-    //return !a;
-    return !a.is_attached();
-}
-
-template <typename T, typename D>
-inline bool operator==(skstd::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, skstd::nullptr_t) /*noexcept*/ {
-    //return (bool)a;
-    return a.is_attached();
-}
-
-template <typename T, typename D>
-inline bool operator!=(skstd::nullptr_t, const unique_ptr<T, D>& b) /*noexcept*/ {
-    //return (bool)b;
-    return b.is_attached();
-}
-
-}  // namespace skstd
-
-#endif
-- 
cgit v1.2.3