...
Run Format

Source file src/syscall/js/func.go

Documentation: syscall/js

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // +build js,wasm
     6  
     7  package js
     8  
     9  import "sync"
    10  
    11  var (
    12  	funcsMu    sync.Mutex
    13  	funcs             = make(map[uint32]func(Value, []Value) interface{})
    14  	nextFuncID uint32 = 1
    15  )
    16  
    17  var _ Wrapper = Func{} // Func must implement Wrapper
    18  
    19  // Func is a wrapped Go function to be called by JavaScript.
    20  type Func struct {
    21  	Value // the JavaScript function that invokes the Go function
    22  	id    uint32
    23  }
    24  
    25  // FuncOf returns a wrapped function.
    26  //
    27  // Invoking the JavaScript function will synchronously call the Go function fn with the value of JavaScript's
    28  // "this" keyword and the arguments of the invocation.
    29  // The return value of the invocation is the result of the Go function mapped back to JavaScript according to ValueOf.
    30  //
    31  // A wrapped function triggered during a call from Go to JavaScript gets executed on the same goroutine.
    32  // A wrapped function triggered by JavaScript's event loop gets executed on an extra goroutine.
    33  // Blocking operations in the wrapped function will block the event loop.
    34  // As a consequence, if one wrapped function blocks, other wrapped funcs will not be processed.
    35  // A blocking function should therefore explicitly start a new goroutine.
    36  //
    37  // Func.Release must be called to free up resources when the function will not be used any more.
    38  func FuncOf(fn func(this Value, args []Value) interface{}) Func {
    39  	funcsMu.Lock()
    40  	id := nextFuncID
    41  	nextFuncID++
    42  	funcs[id] = fn
    43  	funcsMu.Unlock()
    44  	return Func{
    45  		id:    id,
    46  		Value: jsGo.Call("_makeFuncWrapper", id),
    47  	}
    48  }
    49  
    50  // Release frees up resources allocated for the function.
    51  // The function must not be invoked after calling Release.
    52  func (c Func) Release() {
    53  	funcsMu.Lock()
    54  	delete(funcs, c.id)
    55  	funcsMu.Unlock()
    56  }
    57  
    58  // setEventHandler is defined in the runtime package.
    59  func setEventHandler(fn func())
    60  
    61  func init() {
    62  	setEventHandler(handleEvent)
    63  }
    64  
    65  func handleEvent() {
    66  	cb := jsGo.Get("_pendingEvent")
    67  	if cb == Null() {
    68  		return
    69  	}
    70  	jsGo.Set("_pendingEvent", Null())
    71  
    72  	id := uint32(cb.Get("id").Int())
    73  	if id == 0 { // zero indicates deadlock
    74  		select {}
    75  	}
    76  	funcsMu.Lock()
    77  	f, ok := funcs[id]
    78  	funcsMu.Unlock()
    79  	if !ok {
    80  		Global().Get("console").Call("error", "call to released function")
    81  		return
    82  	}
    83  
    84  	this := cb.Get("this")
    85  	argsObj := cb.Get("args")
    86  	args := make([]Value, argsObj.Length())
    87  	for i := range args {
    88  		args[i] = argsObj.Index(i)
    89  	}
    90  	result := f(this, args)
    91  	cb.Set("result", result)
    92  }
    93  

View as plain text