1258fdd639904fc7491810ccaca9fc16dba3202a
[WebKit-https.git] / Source / WTF / wtf / BlockPtr.h
1 /*
2  * Copyright (C) 2016 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 defined(__OBJC__) && __has_feature(objc_arc)
101         BlockPtr blockPtr { (__bridge_transfer BlockType)block };
102 #else
103         BlockPtr blockPtr;
104         blockPtr.m_block = reinterpret_cast<BlockType>(block);
105 #endif
106
107         return blockPtr;
108     }
109
110     BlockPtr()
111         : m_block(nullptr)
112     {
113     }
114
115     BlockPtr(BlockType block)
116 #if defined(__OBJC__) && __has_feature(objc_arc)
117         : m_block(block)
118 #else
119         : m_block(Block_copy(block))
120 #endif
121     {
122     }
123
124     BlockPtr(const BlockPtr& other)
125 #if defined(__OBJC__) && __has_feature(objc_arc)
126         : m_block(other.m_block)
127 #else
128         : m_block(Block_copy(other.m_block))
129 #endif
130     {
131     }
132     
133     BlockPtr(BlockPtr&& other)
134         : m_block(std::exchange(other.m_block, nullptr))
135     {
136     }
137     
138     ~BlockPtr()
139     {
140 #if !defined(__OBJC__) || !__has_feature(objc_arc)
141         Block_release(m_block);
142 #endif
143     }
144
145     BlockPtr& operator=(const BlockPtr& other)
146     {
147 #if defined(__OBJC__) && __has_feature(objc_arc)
148         m_block = other.m_block;
149 #else
150         if (this != &other) {
151             Block_release(m_block);
152             m_block = Block_copy(other.m_block);
153         }
154 #endif
155
156         return *this;
157     }
158
159     BlockPtr& operator=(BlockPtr&& other)
160     {
161         ASSERT(this != &other);
162
163 #if !defined(__OBJC__) || !__has_feature(objc_arc)
164         Block_release(m_block);
165 #endif
166         m_block = std::exchange(other.m_block, nullptr);
167
168         return *this;
169     }
170
171     BlockType get() const { return m_block; }
172
173     explicit operator bool() const { return m_block; }
174     bool operator!() const { return !m_block; }
175
176     R operator()(Args... arguments) const
177     {
178         ASSERT(m_block);
179         
180         return m_block(std::forward<Args>(arguments)...);
181     }
182
183 private:
184     BlockType m_block;
185 };
186
187 template<typename R, typename... Args>
188 inline BlockPtr<R (Args...)> makeBlockPtr(R (^block)(Args...))
189 {
190     return BlockPtr<R (Args...)>(block);
191 }
192
193 }
194
195 using WTF::BlockPtr;
196 using WTF::makeBlockPtr;