1 //
2 // Copyright 2016 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // Observer:
7 // Implements the Observer pattern for sending state change notifications
8 // from Subject objects to dependent Observer objects.
9 //
10 // See design document:
11 // https://docs.google.com/document/d/15Edfotqg6_l1skTEL8ADQudF_oIdNa7i8Po43k6jMd4/
12
13 #ifndef LIBANGLE_OBSERVER_H_
14 #define LIBANGLE_OBSERVER_H_
15
16 #include "common/FastVector.h"
17 #include "common/angleutils.h"
18
19 namespace angle
20 {
21 template <typename HaystackT, typename NeedleT>
IsInContainer(const HaystackT & haystack,const NeedleT & needle)22 bool IsInContainer(const HaystackT &haystack, const NeedleT &needle)
23 {
24 return std::find(haystack.begin(), haystack.end(), needle) != haystack.end();
25 }
26
27 using SubjectIndex = size_t;
28
29 // Messages are used to distinguish different Subject events that get sent to a single Observer.
30 // It could be possible to improve the handling by using different callback functions instead
31 // of a single handler function. But in some cases we want to share a single binding between
32 // Observer and Subject and handle different types of events.
33 enum class SubjectMessage
34 {
35 // Used by gl::VertexArray to notify gl::Context of a gl::Buffer binding count change. Triggers
36 // a validation cache update. Also used by gl::Texture to notify gl::Framebuffer of loops.
37 BindingChanged,
38
39 // Only the contents (pixels, bytes, etc) changed in this Subject. Distinct from the object
40 // storage.
41 ContentsChanged,
42
43 // Sent by gl::Sampler, gl::Texture, gl::Framebuffer and others to notifiy gl::Context. This
44 // flag indicates to call syncState before next use.
45 DirtyBitsFlagged,
46
47 // Generic state change message. Used in multiple places for different purposes.
48 SubjectChanged,
49
50 // Indicates a bound gl::Buffer is now mapped or unmapped. Passed from gl::Buffer, through
51 // gl::VertexArray, into gl::Context. Used to track validation.
52 SubjectMapped,
53 SubjectUnmapped,
54 // Indicates a bound buffer was reallocated when it was mapped, to prevent having to flush
55 // pending commands and waiting for the GPU to become idle.
56 InternalMemoryAllocationChanged,
57
58 //cve-2022-0297 angle
59 // Indicates that a buffer's storage has changed. Used to prevent use-after-free error. (Vulkan)
60 BufferVkStorageChanged,
61
62 // Indicates an external change to the default framebuffer.
63 SurfaceChanged,
64
65 // Indicates a separable program's textures or images changed in the ProgramExecutable.
66 ProgramTextureOrImageBindingChanged,
67 // Indicates a separable program was successfully re-linked.
68 ProgramRelinked,
69 // Indicates a separable program's sampler uniforms were updated.
70 SamplerUniformsUpdated,
71
72 // Indicates a Storage of back-end in gl::Texture has been released.
73 StorageReleased,
74
75 // Indicates that all pending updates are complete in the subject.
76 InitializationComplete,
77 };
78
79 // The observing class inherits from this interface class.
80 class ObserverInterface
81 {
82 public:
83 virtual ~ObserverInterface();
84 virtual void onSubjectStateChange(SubjectIndex index, SubjectMessage message) = 0;
85 };
86
87 class ObserverBindingBase
88 {
89 public:
ObserverBindingBase(ObserverInterface * observer,SubjectIndex subjectIndex)90 ObserverBindingBase(ObserverInterface *observer, SubjectIndex subjectIndex)
91 : mObserver(observer), mIndex(subjectIndex)
92 {}
~ObserverBindingBase()93 virtual ~ObserverBindingBase() {}
94
getObserver()95 ObserverInterface *getObserver() const { return mObserver; }
getSubjectIndex()96 SubjectIndex getSubjectIndex() const { return mIndex; }
97
onSubjectReset()98 virtual void onSubjectReset() {}
99
100 private:
101 ObserverInterface *mObserver;
102 SubjectIndex mIndex;
103 };
104
105 constexpr size_t kMaxFixedObservers = 8;
106
107 // Maintains a list of observer bindings. Sends update messages to the observer.
108 class Subject : NonCopyable
109 {
110 public:
111 Subject();
112 virtual ~Subject();
113
114 void onStateChange(SubjectMessage message) const;
115 bool hasObservers() const;
116 void resetObservers();
117
addObserver(ObserverBindingBase * observer)118 ANGLE_INLINE void addObserver(ObserverBindingBase *observer)
119 {
120 ASSERT(!IsInContainer(mObservers, observer));
121 mObservers.push_back(observer);
122 }
123
removeObserver(ObserverBindingBase * observer)124 ANGLE_INLINE void removeObserver(ObserverBindingBase *observer)
125 {
126 ASSERT(IsInContainer(mObservers, observer));
127 mObservers.remove_and_permute(observer);
128 }
129
130 private:
131 // Keep a short list of observers so we can allocate/free them quickly. But since we support
132 // unlimited bindings, have a spill-over list of that uses dynamic allocation.
133 angle::FastVector<ObserverBindingBase *, kMaxFixedObservers> mObservers;
134 };
135
136 // Keeps a binding between a Subject and Observer, with a specific subject index.
137 class ObserverBinding final : public ObserverBindingBase
138 {
139 public:
140 ObserverBinding(ObserverInterface *observer, SubjectIndex index);
141 ~ObserverBinding() override;
142 ObserverBinding(const ObserverBinding &other);
143 ObserverBinding &operator=(const ObserverBinding &other);
144
145 void bind(Subject *subject);
146
reset()147 ANGLE_INLINE void reset() { bind(nullptr); }
148
149 void onStateChange(SubjectMessage message) const;
150 void onSubjectReset() override;
151
getSubject()152 ANGLE_INLINE const Subject *getSubject() const { return mSubject; }
153
assignSubject(Subject * subject)154 ANGLE_INLINE void assignSubject(Subject *subject) { mSubject = subject; }
155
156 private:
157 Subject *mSubject;
158 };
159
160 } // namespace angle
161
162 #endif // LIBANGLE_OBSERVER_H_
163