[Cocoa] Retire DispatchPtr, and add more move semantics and simpler #ifs to other...
[WebKit-https.git] / Source / WTF / wtf / BlockPtr.h
1 /*
2  * Copyright (C) 2016-2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include <Block.h>
29 #if CPU(ARM64E)
30 #include <WebKitAdditions/BlockQualifiers.h>
31 #else
32 #define WTF_COPY_FUNCTION_POINTER_QUALIFIER
33 #define WTF_DISPOSE_FUNCTION_POINTER_QUALIFIER
34 #define WTF_INVOKE_FUNCTION_POINTER_QUALIFIER
35 #endif
36 #include <utility>
37 #include <wtf/Assertions.h>
38
39 namespace WTF {
40
41 extern "C" void* _NSConcreteMallocBlock[32];
42
43 template<typename> class BlockPtr;
44
45 template<typename R, typename... Args>
46 class BlockPtr<R (Args...)> {
47 public:
48     using BlockType = R (^)(Args...);
49
50     template<typename F>
51     static BlockPtr fromCallable(F function)
52     {
53         struct Descriptor {
54             uintptr_t reserved;
55             uintptr_t size;
56             void (*WTF_COPY_FUNCTION_POINTER_QUALIFIER copy)(void *dst, const void *src);
57             void (*WTF_DISPOSE_FUNCTION_POINTER_QUALIFIER dispose)(const void *);
58         };
59
60         struct Block {
61             void* isa;
62             int32_t flags;
63             int32_t reserved;
64             R (*WTF_INVOKE_FUNCTION_POINTER_QUALIFIER invoke)(void *, Args...);
65             const struct Descriptor* descriptor;
66             F f;
67         };
68
69         static const Descriptor descriptor {
70             0,
71             sizeof(Block),
72
73             // We keep the copy function null - the block is already on the heap
74             // so it should never be copied.
75             nullptr,
76
77             [](const void* ptr) {
78                 static_cast<Block*>(const_cast<void*>(ptr))->f.~F();
79             }
80         };
81
82         Block* block = static_cast<Block*>(malloc(sizeof(Block)));
83         block->isa = _NSConcreteMallocBlock;
84
85         enum {
86             BLOCK_NEEDS_FREE = (1 << 24),
87             BLOCK_HAS_COPY_DISPOSE = (1 << 25),
88         };
89         const unsigned retainCount = 1;
90
91         block->flags = BLOCK_HAS_COPY_DISPOSE | BLOCK_NEEDS_FREE | (retainCount << 1);
92         block->reserved = 0;
93         block->invoke = [](void *ptr, Args... args) -> R {
94             return static_cast<Block*>(ptr)->f(std::forward<Args>(args)...);
95         };
96         block->descriptor = &descriptor;
97
98         new (&block->f) F { std::move(function) };
99
100 #if __has_feature(objc_arc)
101         return BlockPtr { (__bridge_transfer BlockType)block };
102 #else
103         BlockPtr blockPtr;
104         blockPtr.m_block = reinterpret_cast<BlockType>(block);
105         return blockPtr;
106 #endif
107     }
108
109     BlockPtr()
110         : m_block(nullptr)
111     {
112     }
113
114     BlockPtr(BlockType block)
115 #if __has_feature(objc_arc)
116         : m_block(WTFMove(block))
117 #else
118         : m_block(Block_copy(block))
119 #endif
120     {
121     }
122
123     BlockPtr(const BlockPtr& other)
124 #if __has_feature(objc_arc)
125         : m_block(other.m_block)
126 #else
127         : m_block(Block_copy(other.m_block))
128 #endif
129     {
130     }
131     
132     BlockPtr(BlockPtr&& other)
133         : m_block(std::exchange(other.m_block, nullptr))
134     {
135     }
136     
137     ~BlockPtr()
138     {
139 #if !__has_feature(objc_arc)
140         Block_release(m_block);
141 #endif
142     }
143
144     BlockPtr& operator=(const BlockPtr& other)
145     {
146 #if __has_feature(objc_arc)
147         m_block = other.m_block;
148 #else
149         if (this != &other) {
150             Block_release(m_block);
151             m_block = Block_copy(other.m_block);
152         }
153 #endif
154
155         return *this;
156     }
157
158     BlockPtr& operator=(BlockPtr&& other)
159     {
160         ASSERT(this != &other);
161
162 #if !__has_feature(objc_arc)
163         Block_release(m_block);
164 #endif
165         m_block = std::exchange(other.m_block, nullptr);
166
167         return *this;
168     }
169
170     BlockType get() const { return m_block; }
171
172     explicit operator bool() const { return m_block; }
173     bool operator!() const { return !m_block; }
174
175     R operator()(Args... arguments) const
176     {
177         ASSERT(m_block);
178         
179         return m_block(std::forward<Args>(arguments)...);
180     }
181
182 private:
183     BlockType m_block;
184 };
185
186 template<typename R, typename... Args>
187 inline BlockPtr<R (Args...)> makeBlockPtr(R (^block)(Args...))
188 {
189     return BlockPtr<R (Args...)>(block);
190 }
191
192 }
193
194 using WTF::BlockPtr;
195 using WTF::makeBlockPtr;