1 files changed, 177 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/sksl/SkSLThreadContext.h b/gfx/skia/skia/src/sksl/SkSLThreadContext.h
new file mode 100644
index 0000000000..853ec4ed98
--- /dev/null
+++ b/gfx/skia/skia/src/sksl/SkSLThreadContext.h
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKSL_THREADCONTEXT
+#define SKSL_THREADCONTEXT
+
+#include "include/core/SkTypes.h"
+#include "include/sksl/SkSLErrorReporter.h"
+#include "include/sksl/SkSLPosition.h"
+#include "src/sksl/SkSLContext.h"
+#include "src/sksl/SkSLProgramSettings.h"
+#include "src/sksl/ir/SkSLProgram.h"
+
+#include <cstdint>
+#include <memory>
+#include <string_view>
+#include <vector>
+
+namespace SkSL {
+
+class Compiler;
+class ModifiersPool;
+class Pool;
+class ProgramElement;
+class SymbolTable;
+class Variable;
+enum class ProgramKind : int8_t;
+struct Modifiers;
+struct Module;
+
+namespace dsl {
+
+class DSLCore;
+
+} // namespace dsl
+
+/**
+ * Thread-safe class that tracks per-thread state associated with SkSL output.
+ */
+class ThreadContext {
+public:
+    ThreadContext(SkSL::Compiler* compiler,
+                  SkSL::ProgramKind kind,
+                  const SkSL::ProgramSettings& settings,
+                  const SkSL::Module* module,
+                  bool isModule);
+    ~ThreadContext();
+
+    /**
+     * Returns true if the DSL has been started.
+     */
+    static bool IsActive();
+
+    /**
+     * Returns the Compiler used by DSL operations in the current thread.
+     */
+    static SkSL::Compiler& Compiler() { return *Instance().fCompiler; }
+
+    /**
+     * Returns the Context used by DSL operations in the current thread.
+     */
+    static SkSL::Context& Context();
+
+    /**
+     * Returns the Settings used by DSL operations in the current thread.
+     */
+    static const SkSL::ProgramSettings& Settings();
+
+    /**
+     * Returns the Program::Inputs used by the current thread.
+     */
+    static SkSL::Program::Inputs& Inputs() { return Instance().fInputs; }
+
+    /**
+     * Returns the collection to which DSL program elements in this thread should be appended.
+     */
+    static std::vector<std::unique_ptr<SkSL::ProgramElement>>& ProgramElements() {
+        return Instance().fProgramElements;
+    }
+
+    static std::vector<const ProgramElement*>& SharedElements() {
+        return Instance().fSharedElements;
+    }
+
+    /**
+     * Returns the current SymbolTable.
+     */
+    static std::shared_ptr<SkSL::SymbolTable>& SymbolTable();
+
+    /**
+     * Returns the current memory pool.
+     */
+    static std::unique_ptr<Pool>& MemoryPool() { return Instance().fPool; }
+
+    /**
+     * Returns the current modifiers pool.
+     */
+    static std::unique_ptr<ModifiersPool>& GetModifiersPool() { return Instance().fModifiersPool; }
+
+    /**
+     * Returns the current ProgramConfig.
+     */
+    static const std::unique_ptr<ProgramConfig>& GetProgramConfig() { return Instance().fConfig; }
+
+    static bool IsModule() { return GetProgramConfig()->fIsBuiltinCode; }
+
+    /**
+     * Returns the final pointer to a pooled Modifiers object that should be used to represent the
+     * given modifiers.
+     */
+    static const SkSL::Modifiers* Modifiers(const SkSL::Modifiers& modifiers);
+
+    struct RTAdjustData {
+        // Points to a standalone sk_RTAdjust variable, if one exists.
+        const Variable* fVar = nullptr;
+        // Points to the interface block containing an sk_RTAdjust field, if one exists.
+        const Variable* fInterfaceBlock = nullptr;
+        // If fInterfaceBlock is non-null, contains the index of the sk_RTAdjust field within it.
+        int fFieldIndex = -1;
+    };
+
+    /**
+     * Returns a struct containing information about the RTAdjust variable.
+     */
+    static RTAdjustData& RTAdjustState();
+
+    /**
+     * Returns the ErrorReporter associated with the current thread. This object will be notified
+     * when any DSL errors occur.
+     */
+    static ErrorReporter& GetErrorReporter() {
+        return *Context().fErrors;
+    }
+
+    static void SetErrorReporter(ErrorReporter* errorReporter);
+
+    /**
+     * Notifies the current ErrorReporter that an error has occurred. The default error handler
+     * prints the message to stderr and aborts.
+     */
+    static void ReportError(std::string_view msg, Position pos = Position{});
+
+    static ThreadContext& Instance();
+
+    static void SetInstance(std::unique_ptr<ThreadContext> instance);
+
+private:
+    class DefaultErrorReporter : public ErrorReporter {
+        void handleError(std::string_view msg, Position pos) override;
+    };
+
+    void setupSymbolTable();
+
+    std::unique_ptr<SkSL::ProgramConfig> fConfig;
+    std::unique_ptr<SkSL::ModifiersPool> fModifiersPool;
+    SkSL::Compiler* fCompiler;
+    std::unique_ptr<Pool> fPool;
+    SkSL::ProgramConfig* fOldConfig;
+    SkSL::ModifiersPool* fOldModifiersPool;
+    std::vector<std::unique_ptr<SkSL::ProgramElement>> fProgramElements;
+    std::vector<const SkSL::ProgramElement*> fSharedElements;
+    DefaultErrorReporter fDefaultErrorReporter;
+    ErrorReporter& fOldErrorReporter;
+    ProgramSettings fSettings;
+    RTAdjustData fRTAdjust;
+    Program::Inputs fInputs;
+
+    friend class dsl::DSLCore;
+};
+
+} // namespace SkSL
+
+#endif