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

skstd -> std for unique_ptr

Browse Source 
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;client.skia:Perf-Mac10.9-Clang-MacMini6.2-CPU-AVX-x86_64-Release-Trybot

Committed: https://skia.googlesource.com/skia/+/06189155d987db5c7e69015f6ea87c2168d6a065

Review URL: https://codereview.chromium.org/1436033003
This commit is contained in:
mtklein 2015-11-30 07:07:01 -08:00 committed by Commit bot
parent b9a1e34362
commit 70e8dfca4a
10 changed files with 25 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gyp/core.gypi
View File

@ -410,7 +410,6 @@
'<(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 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(); }

6
include/core/SkTypes.h
View File

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

6
include/private/SkOncePtr.h
View File

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

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

396
include/private/SkUniquePtr.h
View File

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

2
src/android/SkBitmapRegionDecoder.cpp
View File

@ -54,7 +54,7 @@ SkBitmapRegionDecoder* SkBitmapRegionDecoder::Create(
SkAndroidCodec::NewFromStream(streamDeleter.detach());
if (nullptr == codec) {
SkCodecPrintf("Error: Failed to create codec.\n");
return NULL;
return nullptr;
}
SkEncodedFormat format = codec->getEncodedFormat();

8
src/core/SkSharedMutex.h
View File

@ -14,7 +14,7 @@
#ifdef SK_DEBUG
#include "SkMutex.h"
#include "SkUniquePtr.h"
#include <memory>
#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;
skstd::unique_ptr<ThreadIDSet> fCurrentShared;
skstd::unique_ptr<ThreadIDSet> fWaitingExclusive;
skstd::unique_ptr<ThreadIDSet> fWaitingShared;
std::unique_ptr<ThreadIDSet> fCurrentShared;
std::unique_ptr<ThreadIDSet> fWaitingExclusive;
std::unique_ptr<ThreadIDSet> fWaitingShared;
int fSharedQueueSelect{0};
mutable SkMutex fMu;
SkSemaphore fSharedQueue[2];

69
tests/CPlusPlusEleven.cpp
View File

@ -27,72 +27,3 @@ 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

@ -290,7 +290,6 @@ BASE_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/android/SkBitmapRegionCanvas.cpp',