1 files changed, 167 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/Observer.h b/gfx/angle/checkout/src/libANGLE/Observer.h
new file mode 100644
index 0000000000..a07a224b99
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/Observer.h
@@ -0,0 +1,167 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Observer:
+//   Implements the Observer pattern for sending state change notifications
+//   from Subject objects to dependent Observer objects.
+//
+//   See design document:
+//   https://docs.google.com/document/d/15Edfotqg6_l1skTEL8ADQudF_oIdNa7i8Po43k6jMd4/
+
+#ifndef LIBANGLE_OBSERVER_H_
+#define LIBANGLE_OBSERVER_H_
+
+#include "common/FastVector.h"
+#include "common/angleutils.h"
+
+namespace angle
+{
+template <typename HaystackT, typename NeedleT>
+bool IsInContainer(const HaystackT &haystack, const NeedleT &needle)
+{
+    return std::find(haystack.begin(), haystack.end(), needle) != haystack.end();
+}
+
+using SubjectIndex = size_t;
+
+// Messages are used to distinguish different Subject events that get sent to a single Observer.
+// It could be possible to improve the handling by using different callback functions instead
+// of a single handler function. But in some cases we want to share a single binding between
+// Observer and Subject and handle different types of events.
+enum class SubjectMessage
+{
+    // Used by gl::VertexArray to notify gl::Context of a gl::Buffer binding count change. Triggers
+    // a validation cache update. Also used by gl::Texture to notify gl::Framebuffer of loops.
+    BindingChanged,
+
+    // Only the contents (pixels, bytes, etc) changed in this Subject. Distinct from the object
+    // storage.
+    ContentsChanged,
+
+    // Sent by gl::Sampler, gl::Texture, gl::Framebuffer and others to notifiy gl::Context. This
+    // flag indicates to call syncState before next use.
+    DirtyBitsFlagged,
+
+    // Generic state change message. Used in multiple places for different purposes.
+    SubjectChanged,
+
+    // Indicates a bound gl::Buffer is now mapped or unmapped. Passed from gl::Buffer, through
+    // gl::VertexArray, into gl::Context. Used to track validation.
+    SubjectMapped,
+    SubjectUnmapped,
+    // Indicates a bound buffer's storage was reallocated due to glBufferData call or optimizations
+    // to prevent having to flush pending commands and waiting for the GPU to become idle.
+    InternalMemoryAllocationChanged,
+
+    // Indicates an external change to the default framebuffer.
+    SurfaceChanged,
+    // Indicates the system framebuffer's swapchain changed, i.e. color buffer changed but no
+    // depth/stencil buffer change.
+    SwapchainImageChanged,
+
+    // Indicates a separable program's textures or images changed in the ProgramExecutable.
+    ProgramTextureOrImageBindingChanged,
+    // Indicates a separable program was successfully re-linked.
+    ProgramRelinked,
+    // Indicates a separable program's sampler uniforms were updated.
+    SamplerUniformsUpdated,
+    // Other types of uniform change.
+    ProgramUniformUpdated,
+
+    // Indicates a Storage of back-end in gl::Texture has been released.
+    StorageReleased,
+
+    // Indicates that all pending updates are complete in the subject.
+    InitializationComplete,
+};
+
+// The observing class inherits from this interface class.
+class ObserverInterface
+{
+  public:
+    virtual ~ObserverInterface();
+    virtual void onSubjectStateChange(SubjectIndex index, SubjectMessage message) = 0;
+};
+
+class ObserverBindingBase
+{
+  public:
+    ObserverBindingBase(ObserverInterface *observer, SubjectIndex subjectIndex)
+        : mObserver(observer), mIndex(subjectIndex)
+    {}
+    virtual ~ObserverBindingBase() {}
+
+    ObserverBindingBase(const ObserverBindingBase &other)            = default;
+    ObserverBindingBase &operator=(const ObserverBindingBase &other) = default;
+
+    ObserverInterface *getObserver() const { return mObserver; }
+    SubjectIndex getSubjectIndex() const { return mIndex; }
+
+    virtual void onSubjectReset() {}
+
+  private:
+    ObserverInterface *mObserver;
+    SubjectIndex mIndex;
+};
+
+constexpr size_t kMaxFixedObservers = 8;
+
+// Maintains a list of observer bindings. Sends update messages to the observer.
+class Subject : NonCopyable
+{
+  public:
+    Subject();
+    virtual ~Subject();
+
+    void onStateChange(SubjectMessage message) const;
+    bool hasObservers() const;
+    void resetObservers();
+    ANGLE_INLINE size_t getObserversCount() const { return mObservers.size(); }
+
+    ANGLE_INLINE void addObserver(ObserverBindingBase *observer)
+    {
+        ASSERT(!IsInContainer(mObservers, observer));
+        mObservers.push_back(observer);
+    }
+    ANGLE_INLINE void removeObserver(ObserverBindingBase *observer)
+    {
+        ASSERT(IsInContainer(mObservers, observer));
+        mObservers.remove_and_permute(observer);
+    }
+
+  private:
+    // Keep a short list of observers so we can allocate/free them quickly. But since we support
+    // unlimited bindings, have a spill-over list of that uses dynamic allocation.
+    angle::FastVector<ObserverBindingBase *, kMaxFixedObservers> mObservers;
+};
+
+// Keeps a binding between a Subject and Observer, with a specific subject index.
+class ObserverBinding final : public ObserverBindingBase
+{
+  public:
+    ObserverBinding();
+    ObserverBinding(ObserverInterface *observer, SubjectIndex index);
+    ~ObserverBinding() override;
+    ObserverBinding(const ObserverBinding &other);
+    ObserverBinding &operator=(const ObserverBinding &other);
+
+    void bind(Subject *subject);
+
+    ANGLE_INLINE void reset() { bind(nullptr); }
+
+    void onStateChange(SubjectMessage message) const;
+    void onSubjectReset() override;
+
+    ANGLE_INLINE const Subject *getSubject() const { return mSubject; }
+
+    ANGLE_INLINE void assignSubject(Subject *subject) { mSubject = subject; }
+
+  private:
+    Subject *mSubject;
+};
+
+}  // namespace angle
+
+#endif  // LIBANGLE_OBSERVER_H_