Revert of skstd -> std for unique_ptr (patchset #9 id:160001 of https://codereview.chromium.org/1436033003/ )

Reason for revert:
10.9 bots are too old too.

Original issue's description:
> skstd -> std for unique_ptr
>
> TBR=reed@google.com
> No public API changes.
>
> BUG=skia:4564
>
> Committed: https://skia.googlesource.com/skia/+/755c553c17b82bb5de3d9cc8d3b2a866ff9e9e50

TBR=bungeman@google.com,mtklein@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:4564

Review URL: https://codereview.chromium.org/1446413002
This commit is contained in:
mtklein 2015-11-16 13:05:37 -08:00 committed by Commit bot
parent 755c553c17
commit 566b23c571
10 changed files with 489 additions and 22 deletions

View File

@ -410,6 +410,7 @@
'<(skia_include_path)/private/SkTHash.h', '<(skia_include_path)/private/SkTHash.h',
'<(skia_include_path)/private/SkThreadID.h', '<(skia_include_path)/private/SkThreadID.h',
'<(skia_include_path)/private/SkTLogic.h', '<(skia_include_path)/private/SkTLogic.h',
'<(skia_include_path)/private/SkUniquePtr.h',
'<(skia_include_path)/private/SkUtility.h', '<(skia_include_path)/private/SkUtility.h',
'<(skia_include_path)/private/SkWeakRefCnt.h', '<(skia_include_path)/private/SkWeakRefCnt.h',

View File

@ -9,8 +9,8 @@
#define SkRefCnt_DEFINED #define SkRefCnt_DEFINED
#include "../private/SkAtomics.h" #include "../private/SkAtomics.h"
#include "../private/SkUniquePtr.h"
#include "SkTypes.h" #include "SkTypes.h"
#include <memory>
/** \class SkRefCntBase /** \class SkRefCntBase
@ -185,9 +185,9 @@ template <typename T> struct SkTUnref {
/** /**
* Utility class that simply unref's its argument in the destructor. * 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: 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(); } T* detach() { return this->release(); }
operator T*() const { return this->get(); } operator T*() const { return this->get(); }

View File

@ -257,7 +257,7 @@ typedef uint8_t SkBool8;
/** Returns 0 or 1 based on the condition /** Returns 0 or 1 based on the condition
*/ */
#define SkToBool(cond) ((cond) != (decltype(cond))0) #define SkToBool(cond) ((cond) != 0)
#define SK_MaxS16 32767 #define SK_MaxS16 32767
#define SK_MinS16 -32767 #define SK_MinS16 -32767

View File

@ -9,7 +9,7 @@
#define SkOncePtr_DEFINED #define SkOncePtr_DEFINED
#include "../private/SkAtomics.h" #include "../private/SkAtomics.h"
#include <memory> #include "SkUniquePtr.h"
template <typename T> class SkBaseOncePtr; 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; #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(). // 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 { class SkOncePtr : SkNoncopyable {
public: public:
SkOncePtr() { sk_bzero(this, sizeof(*this)); } 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. // If you ask for SkOncePtr<T[]>, we'll clean up with delete[] by default.
template <typename T> 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 /* TODO(mtklein): in next CL
typedef SkBaseOncePtr<void> SkOnceFlag; typedef SkBaseOncePtr<void> SkOnceFlag;

View File

@ -13,9 +13,9 @@
#include "SkMath.h" #include "SkMath.h"
#include "SkTLogic.h" #include "SkTLogic.h"
#include "SkTypes.h" #include "SkTypes.h"
#include "SkUniquePtr.h"
#include "SkUtility.h" #include "SkUtility.h"
#include <limits.h> #include <limits.h>
#include <memory>
#include <new> #include <new>
/** \file SkTemplates.h /** \file SkTemplates.h
@ -59,9 +59,9 @@ template <typename R, typename T, R (*P)(T*)> struct SkFunctionWrapper {
function. function.
*/ */
template <typename T, void (*P)(T*)> class SkAutoTCallVProc 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: 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(); } operator T*() const { return this->get(); }
T* detach() { return this->release(); } T* detach() { return this->release(); }
@ -76,9 +76,9 @@ reference is null when the destructor is called, we do not call the
function. function.
*/ */
template <typename T, int (*P)(T*)> class SkAutoTCallIProc 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: 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(); } operator T*() const { return this->get(); }
T* detach() { return this->release(); } T* detach() { return this->release(); }
@ -94,18 +94,18 @@ public:
The size of a SkAutoTDelete is small: sizeof(SkAutoTDelete<T>) == sizeof(T*) 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: 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(); } operator T*() const { return this->get(); }
void free() { this->reset(nullptr); } void free() { this->reset(nullptr); }
T* detach() { return this->release(); } 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: public:
SkAutoTDeleteArray(T array[]) : std::unique_ptr<T[]>(array) {} SkAutoTDeleteArray(T array[]) : skstd::unique_ptr<T[]>(array) {}
void free() { this->reset(nullptr); } void free() { this->reset(nullptr); }
T* detach() { return this->release(); } T* detach() { return this->release(); }

View File

@ -0,0 +1,396 @@
/*
* 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

View File

@ -49,9 +49,9 @@ SkBitmapRegionDecoder* SkBitmapRegionDecoder::Create(
case kAndroidCodec_Strategy: { case kAndroidCodec_Strategy: {
SkAutoTDelete<SkAndroidCodec> codec = SkAutoTDelete<SkAndroidCodec> codec =
SkAndroidCodec::NewFromStream(streamDeleter.detach()); SkAndroidCodec::NewFromStream(streamDeleter.detach());
if (!codec) { if (NULL == codec) {
SkCodecPrintf("Error: Failed to create codec.\n"); SkCodecPrintf("Error: Failed to create codec.\n");
return nullptr; return NULL;
} }
return new SkBitmapRegionCodec(codec.detach()); return new SkBitmapRegionCodec(codec.detach());
} }

View File

@ -14,7 +14,7 @@
#ifdef SK_DEBUG #ifdef SK_DEBUG
#include "SkMutex.h" #include "SkMutex.h"
#include <memory> #include "SkUniquePtr.h"
#endif // SK_DEBUG #endif // SK_DEBUG
// There are two shared lock implementations one debug the other is high performance. They implement // There are two shared lock implementations one debug the other is high performance. They implement
@ -50,9 +50,9 @@ public:
private: private:
#ifdef SK_DEBUG #ifdef SK_DEBUG
class ThreadIDSet; class ThreadIDSet;
std::unique_ptr<ThreadIDSet> fCurrentShared; skstd::unique_ptr<ThreadIDSet> fCurrentShared;
std::unique_ptr<ThreadIDSet> fWaitingExclusive; skstd::unique_ptr<ThreadIDSet> fWaitingExclusive;
std::unique_ptr<ThreadIDSet> fWaitingShared; skstd::unique_ptr<ThreadIDSet> fWaitingShared;
int fSharedQueueSelect{0}; int fSharedQueueSelect{0};
mutable SkMutex fMu; mutable SkMutex fMu;
SkSemaphore fSharedQueue[2]; SkSemaphore fSharedQueue[2];

View File

@ -27,3 +27,72 @@ DEF_TEST(CPlusPlusEleven_RvalueAndMove, r) {
Moveable src1; Moveable dst1(skstd::move(src1)); Moveable src1; Moveable dst1(skstd::move(src1));
Moveable src2, dst2; dst2 = skstd::move(src2); Moveable src2, dst2; dst2 = skstd::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 = skstd::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 = skstd::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 = skstd::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 = skstd::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 = skstd::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 = skstd::move(u);
static_assert(sizeof(u2) == sizeof(SmallUniquePtr), TOO_BIG);
}
}

View File

@ -987,6 +987,7 @@ SRCS = ['include/private/SkAtomics.h',
'include/private/SkTLogic.h', 'include/private/SkTLogic.h',
'include/private/SkTemplates.h', 'include/private/SkTemplates.h',
'include/private/SkThreadID.h', 'include/private/SkThreadID.h',
'include/private/SkUniquePtr.h',
'include/private/SkUtility.h', 'include/private/SkUtility.h',
'include/private/SkWeakRefCnt.h', 'include/private/SkWeakRefCnt.h',
'src/c/sk_c_from_to.h', 'src/c/sk_c_from_to.h',