[GTK] Menu list button doesn't use the text color from the theme
[WebKit-https.git] / Source / WebCore / rendering / RenderPtr.h
1 /*
2  * Copyright (C) 2013 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 #ifndef RenderPtr_h
27 #define RenderPtr_h
28
29 #include <algorithm>
30 #include <cstddef>
31 #include <memory>
32 #include <wtf/Assertions.h>
33 #include <wtf/HashTraits.h>
34
35 namespace WebCore {
36
37 template<typename T> class RenderPtr {
38 public:
39     typedef T ValueType;
40     typedef ValueType* PtrType;
41
42     RenderPtr() : m_ptr(nullptr) { }
43     RenderPtr(std::nullptr_t) : m_ptr(nullptr) { }
44     explicit RenderPtr(T* ptr) : m_ptr(ptr) { }
45
46     ~RenderPtr()
47     {
48         if (m_ptr)
49             m_ptr->destroy();
50     }
51
52     PtrType get() const { return m_ptr; }
53
54     void clear();
55     PtrType leakPtr() WARN_UNUSED_RETURN;
56
57     ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
58     PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
59
60     bool operator!() const { return !m_ptr; }
61
62     // This conversion operator allows implicit conversion to bool but not to other integer types.
63     typedef PtrType RenderPtr::*UnspecifiedBoolType;
64     operator UnspecifiedBoolType() const { return m_ptr ? &RenderPtr::m_ptr : nullptr; }
65
66     RenderPtr& operator=(std::nullptr_t) { clear(); return *this; }
67
68     RenderPtr(RenderPtr&&);
69     template<typename U> RenderPtr(RenderPtr<U>&&);
70
71     RenderPtr& operator=(RenderPtr&&);
72     template<typename U> RenderPtr& operator=(RenderPtr<U>&&);
73
74     void swap(RenderPtr& o) { std::swap(m_ptr, o.m_ptr); }
75
76 private:
77     // We should never have two RenderPtrs for the same underlying object (otherwise we'll get
78     // double-destruction), so these equality operators should never be needed.
79     template<typename U> bool operator==(const RenderPtr<U>&) { COMPILE_ASSERT(!sizeof(U*), RenderPtrs_should_never_be_equal); return false; }
80     template<typename U> bool operator!=(const RenderPtr<U>&) { COMPILE_ASSERT(!sizeof(U*), RenderPtrs_should_never_be_equal); return false; }
81
82     PtrType m_ptr;
83 };
84
85 template<typename T> inline void RenderPtr<T>::clear()
86 {
87     if (m_ptr)
88         m_ptr->destroy();
89     m_ptr = nullptr;
90 }
91
92 template<typename T> inline typename RenderPtr<T>::PtrType RenderPtr<T>::leakPtr()
93 {
94     PtrType ptr = m_ptr;
95     m_ptr = nullptr;
96     return ptr;
97 }
98
99 template<typename T> inline RenderPtr<T>::RenderPtr(RenderPtr<T>&& o)
100     : m_ptr(o.leakPtr())
101 {
102 }
103
104 template<typename T> template<typename U> inline RenderPtr<T>::RenderPtr(RenderPtr<U>&& o)
105     : m_ptr(o.leakPtr())
106 {
107 }
108
109 template<typename T> inline auto RenderPtr<T>::operator=(RenderPtr&& o) -> RenderPtr&
110 {
111     ASSERT(!o || o != m_ptr);
112     RenderPtr ptr = WTFMove(o);
113     swap(ptr);
114     return *this;
115 }
116
117 template<typename T> template<typename U> inline auto RenderPtr<T>::operator=(RenderPtr<U>&& o) -> RenderPtr&
118 {
119     ASSERT(!o || o != m_ptr);
120     RenderPtr ptr = WTFMove(o);
121     swap(ptr);
122     return *this;
123 }
124
125 template<typename T> inline void swap(RenderPtr<T>& a, RenderPtr<T>& b)
126 {
127     a.swap(b);
128 }
129
130 template<typename T, typename U> inline bool operator==(const RenderPtr<T>& a, U* b)
131 {
132     return a.get() == b;
133 }
134
135 template<typename T, typename U> inline bool operator==(T* a, const RenderPtr<U>& b) 
136 {
137     return a == b.get();
138 }
139
140 template<typename T, typename U> inline bool operator!=(const RenderPtr<T>& a, U* b)
141 {
142     return a.get() != b;
143 }
144
145 template<typename T, typename U> inline bool operator!=(T* a, const RenderPtr<U>& b)
146 {
147     return a != b.get();
148 }
149
150 template<typename T> inline typename RenderPtr<T>::PtrType getPtr(const RenderPtr<T>& p)
151 {
152     return p.get();
153 }
154
155 template<class T, class... Args> inline RenderPtr<T>
156 createRenderer(Args&&... args)
157 {
158     return RenderPtr<T>(new T(std::forward<Args>(args)...));
159 }
160
161 template<typename T, typename U> inline RenderPtr<T> static_pointer_cast(RenderPtr<U>&& p)
162 {
163     return RenderPtr<T>(static_cast<T*>(p.leakPtr()));
164 }
165
166 } // namespace WebCore
167
168 namespace WTF {
169
170 template<typename T> struct HashTraits<WebCore::RenderPtr<T>> : SimpleClassHashTraits<WebCore::RenderPtr<T>> {
171     typedef std::nullptr_t EmptyValueType;
172     static EmptyValueType emptyValue() { return nullptr; }
173
174     typedef T* PeekType;
175     static T* peek(const WebCore::RenderPtr<T>& value) { return value.get(); }
176     static T* peek(std::nullptr_t) { return nullptr; }
177 };
178
179 } // namespace WTF
180
181 #endif // RenderPtr_h