mp.input: remove and mitigate race conditions from input.terminate()

This commit ensures that `input.terminate()` can only close input
requests made by the same script, and adds a new
argument to the input.terminate()` function
which allows specifying the specific input request to cancel.

Previosuly, there was no way to guarantee that the input request being
terminated was the one intended; the asynchronous nature of the API
meant that it was always possible (though unlikely) that another client
may have activated its own input request while the termination request
was in transit.

This commit removes the race condition between different scripts calling
`input.terminate()` by sending the script name alongside the termination
message, and provides a backwards compatible way to terminate specific
requests, which removes the race condition for different input requests
within the same script.

Now, `input.get()` and `input.select()` return an opaque id object,
which can be optionally passed into `input.terminate()` to specify which
input request should be terminated.

One advantage of this approach is that it is backwards compatible; a
script passing id values will work without issue on older versions of
mpv as `input.terminate()` previously ignored all of its arguments.

This approach is based on the behaviour of `mp.command_native_async` and
`mp.abort_async_command`.

Author: CogentRedTester

DOCS/man/javascript.rst

@@ -196,11 +196,11 @@ meta-paths like ``~~/foo`` (other JS file functions do expand meta paths).
 ``mp.options.read_options(obj [, identifier [, on_update]])`` (types:
 string/boolean/number)
 
-``mp.input.get(obj)``
+``id = mp.input.get(obj)``
 
-``mp.input.select(obj)``
+``id = mp.input.select(obj)``
 
-``mp.input.terminate()``
+``mp.input.terminate([id])``
 
 ``mp.input.log(message, style)``
 

DOCS/man/lua.rst

@@ -975,8 +975,42 @@ REPL.
         among the ones stored for ``input.get()`` calls. Defaults to the calling
         script name with ``prompt`` appended.
 
-``input.terminate()``
-    Close the console.
+    Returns a table with undefined contents, which can be used as argument for
+    ``input.terminate()``.
+
+``input.terminate([t])``
+    Closes any currently active input request. This will not close
+    requests made by other scripts.
+
+    If the return value of an ``input.get()`` or ``input.select()``
+    request is passed in as the first argument, then only that specific request
+    will be closed, preventing race conditions for scripts that make multiple
+    requests.
+
+    Example:
+
+    ::
+
+        local id, timer
+        id = input.get({
+            prompt = "Open File:\n",
+            history_path = "~~state/open-file-history",
+            opened = function()
+                timer = mp.add_timeout(20, function()
+                    input.terminate(id)
+                end)
+            end,
+            edited = function()
+                timer:kill()
+                timer:resume()
+            end,
+            submit = function(path)
+                mp.commandv("loadfile", path)
+            end,
+            closed = function()
+                timer:kill()
+            end,
+        })
 
 ``input.log(message, style, terminal_style)``
     Add a line to the log buffer. ``style`` can contain additional ASS tags to
@@ -1027,6 +1061,9 @@ REPL.
     ``keep_open``
         Whether to keep the console open on submit. Defaults to ``false``.
 
+    Returns a table with undefined contents, which can be used as argument for
+    ``input.terminate()``.
+
     Example:
 
         ::

player/javascript/defaults.js

@@ -684,9 +684,16 @@ mp.input = {
 
         mp.commandv("script-message-to", "console", "get-input",
                     mp.script_name, handler_id, JSON.stringify(t));
+
+        return {
+            handler_id: handler_id
+        }
     },
-    terminate: function () {
-        mp.commandv("script-message-to", "console", "disable");
+    terminate: function (t) {
+        mp.commandv("script-message-to", "console", "disable", JSON.stringify({
+            script_name: mp.script_name,
+            handler_id: t ? t.handler_id : undefined,
+        }));
     },
     log: function (message, style, terminal_style) {
         mp.commandv("script-message-to", "console", "log", JSON.stringify({

player/lua/console.lua

@@ -1659,8 +1659,15 @@ set_active = function (active)
     render()
 end
 
-mp.register_script_message("disable", function()
-    set_active(false)
+mp.register_script_message("disable", function(message)
+    message = utils.parse_json(message)
+
+    if not message
+        or not message.handler_id and message.script_name == input_caller
+        or message.script_name == input_caller and message.handler_id == input_caller_handler
+    then
+        set_active(false)
+    end
 end)
 
 mp.register_script_message("get-input", function (script_name, handler_id, args)

player/lua/input.lua

@@ -61,12 +61,19 @@ function input.get(t)
     local handler_id = register_event_handler(t)
     mp.commandv("script-message-to", "console", "get-input",
                 mp.get_script_name(), handler_id, utils.format_json(get_non_callbacks(t)))
+
+    return {
+        handler_id = handler_id
+    }
 end
 
 input.select = input.get
 
-function input.terminate()
-    mp.commandv("script-message-to", "console", "disable")
+function input.terminate(t)
+    mp.commandv("script-message-to", "console", "disable", utils.format_json({
+        script_name = mp.get_script_name(),
+        handler_id = t and t.handler_id
+    }))
 end
 
 function input.log(message, style, terminal_style)