| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296 |
- // Package nativehost dispatches worker RPC calls onto a native UI thread.
- package nativehost
- import (
- "context"
- "encoding/json"
- "strings"
- "sync"
- "clusterflow.dev/cfbrowser/api"
- "clusterflow.dev/cfbrowser/internal/capture"
- "clusterflow.dev/cfbrowser/protocol"
- )
- // Backend methods and their completion callbacks must run on the UI thread.
- // A method reports its synchronous or asynchronous result exactly once.
- type Backend interface {
- Configure(api.EngineOptions, func(error))
- NewPage(uint64, func(error))
- Navigate(uint64, string, string, func(string, error))
- Evaluate(uint64, string, func(json.RawMessage, error))
- ClosePage(uint64) error
- Close()
- }
- type captureBackend interface {
- Capture(uint64, bool, func([]byte, error))
- }
- type inputBackend interface {
- Input(uint64, string, string, float64, float64, func(error))
- }
- type result struct {
- value any
- err error
- }
- type Host struct {
- Queue chan func()
- backend Backend
- options api.EngineOptions
- configured bool
- configuring bool
- pages map[uint64]bool
- next uint64
- evaluations int
- nextEvaluation uint64
- pending map[uint64]map[uint64]func()
- }
- func New(backend Backend) *Host {
- return &Host{Queue: make(chan func(), 32), backend: backend, pages: map[uint64]bool{}, pending: map[uint64]map[uint64]func(){}}
- }
- func (h *Host) call(ctx context.Context, start func(func(any, error))) (any, error) {
- if err := ctx.Err(); err != nil {
- return nil, err
- }
- done := make(chan result, 1)
- var once sync.Once
- complete := func(v any, e error) { once.Do(func() { done <- result{v, e} }) }
- select {
- case h.Queue <- func() {
- if err := ctx.Err(); err != nil {
- complete(nil, err)
- return
- }
- start(complete)
- }:
- case <-ctx.Done():
- return nil, ctx.Err()
- }
- select {
- case r := <-done:
- return r.value, r.err
- case <-ctx.Done():
- return nil, ctx.Err()
- }
- }
- func (h *Host) Handle(ctx context.Context, method string, raw json.RawMessage) (any, error) {
- if method == "configure" {
- var opts api.EngineOptions
- if err := json.Unmarshal(raw, &opts); err != nil {
- return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid engine options")
- }
- if opts.ViewportWidth == 0 {
- opts.ViewportWidth = 1280
- }
- if opts.ViewportHeight == 0 {
- opts.ViewportHeight = 800
- }
- if opts.ViewportWidth < 1 || opts.ViewportWidth > 4096 || opts.ViewportHeight < 1 || opts.ViewportHeight > 4096 {
- return nil, api.Err("BROWSER_INVALID_CONFIG", "viewport must be between 1 and 4096 pixels")
- }
- return h.call(ctx, func(done func(any, error)) {
- if h.configured || h.configuring {
- done(nil, api.Err("BROWSER_INVALID_CONFIG", "worker is already configured"))
- return
- }
- h.options = opts
- h.configuring = true
- h.backend.Configure(opts, func(err error) { h.configuring = false; h.configured = err == nil; done(err == nil, err) })
- })
- }
- var args struct {
- Page uint64 `json:"page"`
- FullPage bool `json:"fullPage"`
- Action string `json:"action"`
- Value string `json:"value"`
- X float64 `json:"x"`
- Y float64 `json:"y"`
- URL string `json:"url"`
- Op string `json:"op"`
- Script string `json:"script"`
- }
- if method != "page.new" && method != "session.features" {
- if err := json.Unmarshal(raw, &args); err != nil {
- return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid page arguments")
- }
- }
- return h.call(ctx, func(done func(any, error)) {
- if !h.configured {
- done(nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first"))
- return
- }
- if method == "session.features" {
- done(map[string]int{"featureVersion": protocol.FeatureVersion}, nil)
- return
- }
- if method == "page.new" {
- if len(h.pages) >= 16 {
- done(nil, api.Err("BROWSER_LIMIT", "native page quota reached"))
- return
- }
- h.next++
- id := h.next
- h.pages[id] = true
- h.backend.NewPage(id, func(err error) {
- if err != nil {
- delete(h.pages, id)
- done(nil, err)
- return
- }
- if ctx.Err() != nil {
- _ = h.backend.ClosePage(id)
- delete(h.pages, id)
- done(nil, ctx.Err())
- return
- }
- done(id, nil)
- })
- return
- }
- if method != "page.navigate" && method != "page.evaluate" && method != "page.close" && method != "page.capture" && method != "page.input" {
- done(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "unknown native worker method"))
- return
- }
- if !h.pages[args.Page] {
- done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page is unavailable"))
- return
- }
- switch method {
- case "page.capture", "page.input":
- if h.evaluations >= 32 {
- done(nil, api.Err("BROWSER_LIMIT", "too many native operations pending"))
- return
- }
- complete := h.track(args.Page, done)
- if method == "page.input" {
- backend, ok := h.backend.(inputBackend)
- if !ok {
- complete(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "native trusted input is unavailable"))
- return
- }
- backend.Input(args.Page, args.Action, args.Value, args.X, args.Y, func(err error) { complete(true, err) })
- } else {
- backend, ok := h.backend.(captureBackend)
- if !ok {
- complete(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "native capture is unavailable"))
- return
- }
- captureCompleted := false
- backend.Capture(args.Page, args.FullPage, func(data []byte, err error) {
- if captureCompleted {
- return
- }
- captureCompleted = true
- if ctx.Err() != nil {
- complete(nil, ctx.Err())
- return
- }
- if !h.pages[args.Page] {
- complete(nil, api.Err("BROWSER_CLOSED", "page closed during capture"))
- return
- }
- var name string
- if err == nil {
- name, err = capture.Save(h.options.DownloadDir, data)
- }
- complete(name, err)
- })
- }
- case "page.close":
- delete(h.pages, args.Page)
- h.cancelEvaluations(args.Page)
- done(true, h.backend.ClosePage(args.Page))
- case "page.navigate":
- if strings.ContainsRune(args.URL, 0) {
- done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "URL contains NUL"))
- return
- }
- if args.Op != "goto" && args.Op != "back" && args.Op != "forward" && args.Op != "reload" {
- done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation"))
- return
- }
- h.backend.Navigate(args.Page, args.URL, args.Op, func(url string, err error) { done(url, err) })
- case "page.evaluate":
- if strings.ContainsRune(args.Script, 0) {
- done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "script contains NUL"))
- return
- }
- if len(args.Script) > protocol.MaxMessage/2 {
- done(nil, api.Err("BROWSER_ARGUMENT_LIMIT", "script exceeds worker limit"))
- return
- }
- if h.evaluations >= 32 {
- done(nil, api.Err("BROWSER_LIMIT", "too many native evaluations pending"))
- return
- }
- h.evaluations++
- h.nextEvaluation++
- evaluation := h.nextEvaluation
- if h.pending[args.Page] == nil {
- h.pending[args.Page] = map[uint64]func(){}
- }
- finished := false
- complete := func(value json.RawMessage, err error) {
- if finished {
- return
- }
- finished = true
- h.evaluations--
- delete(h.pending[args.Page], evaluation)
- if len(h.pending[args.Page]) == 0 {
- delete(h.pending, args.Page)
- }
- if err == nil && (len(value) > protocol.MaxMessage-1024 || !json.Valid(value)) {
- err = api.Err("BROWSER_INVALID_RESULT", "native evaluation did not return bounded JSON")
- }
- done(value, err)
- }
- h.pending[args.Page][evaluation] = func() { complete(nil, api.Err("BROWSER_CLOSED", "page closed during evaluation")) }
- h.backend.Evaluate(args.Page, args.Script, complete)
- }
- })
- }
- // Close is called on the UI thread after protocol handlers have been canceled.
- func (h *Host) Close() {
- for page := range h.pending {
- h.cancelEvaluations(page)
- }
- h.pages = map[uint64]bool{}
- h.backend.Close()
- }
- func (h *Host) cancelEvaluations(page uint64) {
- for _, cancel := range h.pending[page] {
- cancel()
- }
- }
- func (h *Host) track(page uint64, done func(any, error)) func(any, error) {
- h.evaluations++
- h.nextEvaluation++
- id := h.nextEvaluation
- if h.pending[page] == nil {
- h.pending[page] = map[uint64]func(){}
- }
- finished := false
- complete := func(v any, e error) {
- if finished {
- return
- }
- finished = true
- h.evaluations--
- delete(h.pending[page], id)
- if len(h.pending[page]) == 0 {
- delete(h.pending, page)
- }
- done(v, e)
- }
- h.pending[page][id] = func() { complete(nil, api.Err("BROWSER_CLOSED", "page closed during operation")) }
- return complete
- }
|