AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gyp/core.gypi
View File

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

6
include/core/SkRefCnt.h
View File

@ -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 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(); }

2
include/core/SkTypes.h
View File

@ -257,7 +257,7 @@ typedef uint8_t SkBool8;
/** 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_MinS16 -32767

6
include/private/SkOncePtr.h
View File

@ -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;

18
include/private/SkTemplates.h
View File

@ -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 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(); }
@ -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 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(); }
@ -94,18 +94,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(); }

396
include/private/SkUniquePtr.h Normal file
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

4
src/android/SkBitmapRegionDecoder.cpp
View File

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

8
src/core/SkSharedMutex.h
View File

@ -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];

69
tests/CPlusPlusEleven.cpp
View File

@ -27,3 +27,72 @@ DEF_TEST(CPlusPlusEleven_RvalueAndMove, r) {
Moveable src1; Moveable dst1(skstd::move(src1));
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);
}
}

1
tools/BUILD.public.expected
View File

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