windows.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577
  1. //go:build windows && (amd64 || arm64)
  2. package nativehost
  3. import (
  4. "encoding/json"
  5. "fmt"
  6. "os"
  7. "path/filepath"
  8. "runtime"
  9. "syscall"
  10. "time"
  11. "unicode/utf16"
  12. "unsafe"
  13. "clusterflow.dev/cfbrowser/api"
  14. "clusterflow.dev/cfbrowser/internal/capture"
  15. "clusterflow.dev/cfbrowser/internal/devtools"
  16. "clusterflow.dev/cfbrowser/protocol"
  17. "encoding/base64"
  18. "github.com/wailsapp/go-webview2/pkg/combridge"
  19. "github.com/wailsapp/go-webview2/webviewloader"
  20. "golang.org/x/sys/windows"
  21. )
  22. // Slots are the published ICoreWebView2/Controller ABI, including IUnknown.
  23. // Only the loader and COM lifetime bridge are reused; no application bridge is installed.
  24. type winObject struct{ table *[64]uintptr }
  25. //go:uintptrescapes
  26. func (o *winObject) call(slot int, args ...uintptr) uintptr {
  27. all := append([]uintptr{uintptr(unsafe.Pointer(o))}, args...)
  28. hr, _, _ := syscall.SyscallN(o.table[slot], all...)
  29. runtime.KeepAlive(o)
  30. return hr
  31. }
  32. func (o *winObject) release() {
  33. if o != nil {
  34. o.call(2)
  35. }
  36. }
  37. func hrError(hr uintptr) error {
  38. if int32(hr) < 0 {
  39. return fmt.Errorf("WebView2 HRESULT 0x%08x", uint32(hr))
  40. }
  41. return nil
  42. }
  43. type controllerCallback interface {
  44. Complete(uintptr, *winObject) uintptr
  45. }
  46. type navigationStartCallback interface {
  47. Started(*winObject, *winObject) uintptr
  48. }
  49. type navigationDoneCallback interface {
  50. Finished(*winObject, *winObject) uintptr
  51. }
  52. type protocolCallback interface {
  53. Completed(uintptr, *uint16) uintptr
  54. }
  55. type controllerDone struct{ fn func(uintptr, *winObject) }
  56. func (c *controllerDone) Complete(hr uintptr, o *winObject) uintptr { c.fn(hr, o); return 0 }
  57. type navStart struct{ fn func(*winObject) }
  58. func (c *navStart) Started(_ *winObject, args *winObject) uintptr { c.fn(args); return 0 }
  59. type navDone struct{ fn func(*winObject) }
  60. func (c *navDone) Finished(_ *winObject, args *winObject) uintptr { c.fn(args); return 0 }
  61. type cdpDone struct{ fn func(uintptr, *uint16) }
  62. func (c *cdpDone) Completed(hr uintptr, s *uint16) uintptr { c.fn(hr, s); return 0 }
  63. func init() {
  64. combridge.RegisterVTable[combridge.IUnknown, controllerCallback]("{6C4819F3-C9B7-4260-8127-C9F5BDE7F68C}", func(this, hr uintptr, o *winObject) uintptr {
  65. return combridge.Resolve[controllerCallback](this).Complete(hr, o)
  66. })
  67. combridge.RegisterVTable[combridge.IUnknown, navigationStartCallback]("{9ADBE429-F36D-432B-9DDC-F8881FBD76E3}", func(this uintptr, sender, args *winObject) uintptr {
  68. return combridge.Resolve[navigationStartCallback](this).Started(sender, args)
  69. })
  70. combridge.RegisterVTable[combridge.IUnknown, navigationDoneCallback]("{D33A35BF-1C49-4F98-93AB-006E0533FE1C}", func(this uintptr, sender, args *winObject) uintptr {
  71. return combridge.Resolve[navigationDoneCallback](this).Finished(sender, args)
  72. })
  73. combridge.RegisterVTable[combridge.IUnknown, protocolCallback]("{5C4889F0-5EF6-4C5A-952C-D8F1B92D0574}", func(this, hr uintptr, s *uint16) uintptr {
  74. return combridge.Resolve[protocolCallback](this).Completed(hr, s)
  75. })
  76. }
  77. var user32 = windows.NewLazySystemDLL("user32.dll")
  78. var registerClass = user32.NewProc("RegisterClassExW")
  79. var createWindow = user32.NewProc("CreateWindowExW")
  80. var defWindowProc = user32.NewProc("DefWindowProcW")
  81. var destroyWindow = user32.NewProc("DestroyWindow")
  82. var showWindow = user32.NewProc("ShowWindow")
  83. var peekMessage = user32.NewProc("PeekMessageW")
  84. var translateMessage = user32.NewProc("TranslateMessage")
  85. var dispatchMessage = user32.NewProc("DispatchMessageW")
  86. var adjustRect = user32.NewProc("AdjustWindowRectEx")
  87. var wndProc = windows.NewCallback(func(hwnd uintptr, msg uint32, wparam, lparam uintptr) uintptr {
  88. if msg == 0x0010 {
  89. showWindow.Call(hwnd, 0)
  90. return 0
  91. }
  92. r, _, _ := defWindowProc.Call(hwnd, uintptr(msg), wparam, lparam)
  93. return r
  94. })
  95. type winRect struct{ Left, Top, Right, Bottom int32 }
  96. type winPoint struct{ X, Y int32 }
  97. type winMessage struct {
  98. Window uintptr
  99. Message uint32
  100. WParam, LParam uintptr
  101. Time uint32
  102. Point winPoint
  103. Private uint32
  104. }
  105. type winClass struct {
  106. Size, Style uint32
  107. Procedure uintptr
  108. ClassExtra, WindowExtra int32
  109. Instance, Icon, Cursor, Background uintptr
  110. Menu, Name *uint16
  111. SmallIcon uintptr
  112. }
  113. type winPage struct {
  114. window uintptr
  115. controller, view *winObject
  116. start *combridge.ComObject[navigationStartCallback]
  117. finish *combridge.ComObject[navigationDoneCallback]
  118. startToken, finishToken int64
  119. navigationID uint64
  120. navigate func(string, error)
  121. closed bool
  122. }
  123. type Windows struct {
  124. options api.EngineOptions
  125. environment *winObject
  126. pages map[uint64]*winPage
  127. processes map[uint32]bool
  128. className *uint16
  129. instance uintptr
  130. initialized bool
  131. closed bool
  132. temporary string
  133. }
  134. func NewWindows() (*Windows, error) {
  135. hr := windows.CoInitializeEx(0, windows.COINIT_APARTMENTTHREADED)
  136. if hr != nil {
  137. return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 requires an STA UI thread")
  138. }
  139. w := &Windows{pages: map[uint64]*winPage{}, processes: map[uint32]bool{}, initialized: true}
  140. var module windows.Handle
  141. err := windows.GetModuleHandleEx(windows.GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, nil, &module)
  142. if err != nil {
  143. w.Close()
  144. return nil, err
  145. }
  146. w.instance = uintptr(module)
  147. w.className, _ = windows.UTF16PtrFromString("CFBrowserNativeWebView2")
  148. class := winClass{Size: uint32(unsafe.Sizeof(winClass{})), Procedure: wndProc, Instance: w.instance, Name: w.className}
  149. r, _, err := registerClass.Call(uintptr(unsafe.Pointer(&class)))
  150. if r == 0 && err != windows.ERROR_CLASS_ALREADY_EXISTS {
  151. w.Close()
  152. return nil, err
  153. }
  154. return w, nil
  155. }
  156. type environmentDone struct {
  157. fn func(webviewloader.HRESULT, *webviewloader.ICoreWebView2Environment)
  158. }
  159. func (e *environmentDone) EnvironmentCompleted(hr webviewloader.HRESULT, env *webviewloader.ICoreWebView2Environment) webviewloader.HRESULT {
  160. e.fn(hr, env)
  161. return 0
  162. }
  163. func (w *Windows) Configure(opts api.EngineOptions, done func(error)) {
  164. w.options = opts
  165. root := opts.DownloadDir
  166. if root == "" {
  167. var err error
  168. root, err = os.MkdirTemp("", "cfbrowser-webview2-")
  169. if err != nil {
  170. done(err)
  171. return
  172. }
  173. w.temporary = root
  174. }
  175. profile, err := filepath.Abs(filepath.Join(root, "webview2-profile"))
  176. if err != nil {
  177. done(err)
  178. return
  179. }
  180. args := "--disable-background-networking --disable-quic"
  181. if opts.NoSandbox {
  182. args += " --no-sandbox"
  183. }
  184. err = webviewloader.CreateCoreWebView2EnvironmentWithOptions(&environmentDone{fn: func(hr webviewloader.HRESULT, env *webviewloader.ICoreWebView2Environment) {
  185. if err := hrError(uintptr(uint32(hr))); err != nil {
  186. done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", err.Error()))
  187. return
  188. }
  189. if env == nil {
  190. done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 returned no environment"))
  191. return
  192. }
  193. if w.closed {
  194. done(api.Err("BROWSER_CLOSED", "worker is closing"))
  195. return
  196. }
  197. env.AddRef()
  198. w.environment = (*winObject)(unsafe.Pointer(env))
  199. done(nil)
  200. }}, webviewloader.WithUserDataFolder(profile), webviewloader.WithAdditionalBrowserArguments(args), webviewloader.WithExclusiveUserDataFolderAccess(true))
  201. if err != nil {
  202. done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "cannot create WebView2 environment; install the Evergreen WebView2 Runtime: "+err.Error()))
  203. }
  204. }
  205. func (w *Windows) NewPage(id uint64, done func(error)) {
  206. if w.environment == nil {
  207. done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 environment is unavailable"))
  208. return
  209. }
  210. const style = 0x00CA0000 | 0x02000000
  211. rect := winRect{Right: int32(w.options.ViewportWidth), Bottom: int32(w.options.ViewportHeight)}
  212. adjustRect.Call(uintptr(unsafe.Pointer(&rect)), style, 0, 0)
  213. title, _ := windows.UTF16PtrFromString("CFBrowser")
  214. hwnd, _, err := createWindow.Call(0, uintptr(unsafe.Pointer(w.className)), uintptr(unsafe.Pointer(title)), style, 0, 0, uintptr(rect.Right-rect.Left), uintptr(rect.Bottom-rect.Top), 0, 0, w.instance, 0)
  215. if hwnd == 0 {
  216. done(err)
  217. return
  218. }
  219. p := &winPage{window: hwnd}
  220. w.pages[id] = p
  221. callback := combridge.New[controllerCallback](&controllerDone{fn: func(hr uintptr, controller *winObject) {
  222. if err := hrError(hr); err != nil || controller == nil {
  223. _ = w.ClosePage(id)
  224. if err == nil {
  225. err = api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 returned no controller")
  226. }
  227. done(err)
  228. return
  229. }
  230. controller.call(1)
  231. p.controller = controller
  232. if p.closed || w.closed {
  233. controller.call(24)
  234. controller.release()
  235. p.controller = nil
  236. done(api.Err("BROWSER_CLOSED", "page closed during startup"))
  237. return
  238. }
  239. if err := hrError(controller.call(25, uintptr(unsafe.Pointer(&p.view)))); err != nil {
  240. _ = w.ClosePage(id)
  241. done(err)
  242. return
  243. }
  244. if err := putControllerBounds(controller, winRect{Right: int32(w.options.ViewportWidth), Bottom: int32(w.options.ViewportHeight)}); err != nil {
  245. _ = w.ClosePage(id)
  246. done(err)
  247. return
  248. }
  249. if err := hrError(controller.call(4, 1)); err != nil {
  250. _ = w.ClosePage(id)
  251. done(err)
  252. return
  253. }
  254. var settings *winObject
  255. if err := hrError(p.view.call(3, uintptr(unsafe.Pointer(&settings)))); err != nil {
  256. _ = w.ClosePage(id)
  257. done(err)
  258. return
  259. }
  260. for _, slot := range []int{6, 8, 12, 16} {
  261. if err := hrError(settings.call(slot, 0)); err != nil {
  262. settings.release()
  263. _ = w.ClosePage(id)
  264. done(err)
  265. return
  266. }
  267. }
  268. settings.release()
  269. p.start = combridge.New[navigationStartCallback](&navStart{fn: func(args *winObject) {
  270. if p.navigate != nil {
  271. var navID uint64
  272. if hrError(args.call(9, uintptr(unsafe.Pointer(&navID)))) == nil {
  273. p.navigationID = navID
  274. }
  275. }
  276. }})
  277. p.finish = combridge.New[navigationDoneCallback](&navDone{fn: func(args *winObject) {
  278. if p.closed || p.navigate == nil {
  279. return
  280. }
  281. var navID uint64
  282. if hrError(args.call(5, uintptr(unsafe.Pointer(&navID)))) != nil || navID != p.navigationID {
  283. return
  284. }
  285. var success int32
  286. err := hrError(args.call(3, uintptr(unsafe.Pointer(&success))))
  287. cb := p.navigate
  288. p.navigate = nil
  289. if err != nil || success == 0 {
  290. cb("", api.Err("BROWSER_NAVIGATION_FAILED", "WebView2 navigation failed"))
  291. return
  292. }
  293. url, err := p.source()
  294. cb(url, err)
  295. }})
  296. if err := hrError(p.view.call(7, p.start.Ref(), uintptr(unsafe.Pointer(&p.startToken)))); err != nil {
  297. _ = w.ClosePage(id)
  298. done(err)
  299. return
  300. }
  301. if err := hrError(p.view.call(15, p.finish.Ref(), uintptr(unsafe.Pointer(&p.finishToken)))); err != nil {
  302. _ = w.ClosePage(id)
  303. done(err)
  304. return
  305. }
  306. var pid uint32
  307. if hrError(p.view.call(37, uintptr(unsafe.Pointer(&pid)))) == nil && pid != 0 {
  308. w.processes[pid] = true
  309. }
  310. if !w.options.Headless {
  311. showWindow.Call(hwnd, 4)
  312. }
  313. done(nil)
  314. }})
  315. err = hrError(w.environment.call(3, hwnd, callback.Ref()))
  316. _ = callback.Close()
  317. if err != nil {
  318. _ = w.ClosePage(id)
  319. done(err)
  320. }
  321. }
  322. func (p *winPage) source() (string, error) {
  323. var value *uint16
  324. if err := hrError(p.view.call(4, uintptr(unsafe.Pointer(&value)))); err != nil {
  325. return "", err
  326. }
  327. defer windows.CoTaskMemFree(unsafe.Pointer(value))
  328. return boundedUTF16(value, 8192)
  329. }
  330. func boundedUTF16(ptr *uint16, limit int) (string, error) {
  331. if ptr == nil {
  332. return "", nil
  333. }
  334. units := make([]uint16, 0, 256)
  335. for i := 0; i <= limit; i++ {
  336. c := *(*uint16)(unsafe.Add(unsafe.Pointer(ptr), i*2))
  337. if c == 0 {
  338. return string(utf16.Decode(units)), nil
  339. }
  340. if i == limit {
  341. return "", api.Err("BROWSER_RESULT_LIMIT", "WebView2 string exceeds worker limit")
  342. }
  343. units = append(units, c)
  344. }
  345. return "", api.Err("BROWSER_INVALID_RESULT", "invalid UTF-16 string")
  346. }
  347. func (w *Windows) Navigate(id uint64, url, op string, done func(string, error)) {
  348. p := w.pages[id]
  349. if p == nil || p.closed || p.view == nil {
  350. done("", api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed"))
  351. return
  352. }
  353. if p.navigate != nil {
  354. old := p.navigate
  355. p.navigate = nil
  356. p.view.call(43)
  357. old("", api.Err("BROWSER_CANCELED", "navigation superseded"))
  358. }
  359. if op == "back" || op == "forward" {
  360. slot := 38
  361. if op == "forward" {
  362. slot = 39
  363. }
  364. var can int32
  365. if err := hrError(p.view.call(slot, uintptr(unsafe.Pointer(&can)))); err != nil {
  366. done("", err)
  367. return
  368. }
  369. if can == 0 {
  370. value, err := p.source()
  371. done(value, err)
  372. return
  373. }
  374. }
  375. p.navigationID = 0
  376. p.navigate = done
  377. var err error
  378. switch op {
  379. case "goto":
  380. var value *uint16
  381. value, err = windows.UTF16PtrFromString(url)
  382. if err == nil {
  383. err = hrError(p.view.call(5, uintptr(unsafe.Pointer(value))))
  384. }
  385. case "reload":
  386. err = hrError(p.view.call(31))
  387. case "back":
  388. err = hrError(p.view.call(40))
  389. case "forward":
  390. err = hrError(p.view.call(41))
  391. default:
  392. err = api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation")
  393. }
  394. if err != nil {
  395. p.navigate = nil
  396. done("", err)
  397. }
  398. }
  399. func (w *Windows) Evaluate(id uint64, script string, done func(json.RawMessage, error)) {
  400. p := w.pages[id]
  401. if p == nil || p.closed || p.view == nil {
  402. done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed"))
  403. return
  404. }
  405. CDPEvaluate(CDPCall(w.protocolCall(p)), script, done)
  406. }
  407. func (w *Windows) protocolCall(p *winPage) devtools.Call {
  408. return func(method string, params json.RawMessage, cb func(json.RawMessage, error)) {
  409. if p.closed || w.closed {
  410. cb(nil, api.Err("BROWSER_CLOSED", "page closed during evaluation"))
  411. return
  412. }
  413. methodPtr, err := windows.UTF16PtrFromString(method)
  414. if err != nil {
  415. cb(nil, err)
  416. return
  417. }
  418. paramsPtr, err := windows.UTF16PtrFromString(string(params))
  419. if err != nil {
  420. cb(nil, err)
  421. return
  422. }
  423. responseLimit := protocol.MaxMessage
  424. if method == "Page.captureScreenshot" {
  425. responseLimit = base64.StdEncoding.EncodedLen(capture.MaxBytes) + 1024
  426. }
  427. callback := combridge.New[protocolCallback](&cdpDone{fn: func(hr uintptr, value *uint16) {
  428. if err := hrError(hr); err != nil {
  429. cb(nil, err)
  430. return
  431. }
  432. s, err := boundedUTF16(value, responseLimit)
  433. cb(json.RawMessage(s), err)
  434. }})
  435. err = hrError(p.view.call(36, uintptr(unsafe.Pointer(methodPtr)), uintptr(unsafe.Pointer(paramsPtr)), callback.Ref()))
  436. _ = callback.Close()
  437. if err != nil {
  438. cb(nil, err)
  439. }
  440. }
  441. }
  442. func (w *Windows) Input(id uint64, action, value string, x, y float64, done func(error)) {
  443. p := w.pages[id]
  444. if p == nil || p.closed || p.view == nil {
  445. done(api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed"))
  446. return
  447. }
  448. devtools.Input(w.protocolCall(p), action, value, x, y, done)
  449. }
  450. func (w *Windows) Capture(id uint64, full bool, done func([]byte, error)) {
  451. p := w.pages[id]
  452. if p == nil || p.closed || p.view == nil {
  453. done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed"))
  454. return
  455. }
  456. devtools.Capture(w.protocolCall(p), full, done)
  457. }
  458. func (w *Windows) ClosePage(id uint64) error {
  459. p := w.pages[id]
  460. if p == nil {
  461. return nil
  462. }
  463. delete(w.pages, id)
  464. p.closed = true
  465. if p.navigate != nil {
  466. cb := p.navigate
  467. p.navigate = nil
  468. cb("", api.Err("BROWSER_CLOSED", "page closed"))
  469. }
  470. if p.view != nil {
  471. if p.start != nil {
  472. p.view.call(8, uintptr(p.startToken))
  473. }
  474. if p.finish != nil {
  475. p.view.call(16, uintptr(p.finishToken))
  476. }
  477. }
  478. if p.controller != nil {
  479. p.controller.call(24)
  480. }
  481. if p.start != nil {
  482. _ = p.start.Close()
  483. }
  484. if p.finish != nil {
  485. _ = p.finish.Close()
  486. }
  487. p.view.release()
  488. p.controller.release()
  489. p.view = nil
  490. p.controller = nil
  491. if p.window != 0 {
  492. destroyWindow.Call(p.window)
  493. p.window = 0
  494. }
  495. return nil
  496. }
  497. func (w *Windows) Pump() error {
  498. for i := 0; i < 100; i++ {
  499. var message winMessage
  500. result, _, _ := peekMessage.Call(uintptr(unsafe.Pointer(&message)), 0, 0, 0, 1)
  501. if result == 0 {
  502. return nil
  503. }
  504. if message.Message == 0x12 {
  505. return api.Err("BROWSER_CLOSED", "Windows message loop stopped")
  506. }
  507. translateMessage.Call(uintptr(unsafe.Pointer(&message)))
  508. dispatchMessage.Call(uintptr(unsafe.Pointer(&message)))
  509. }
  510. return nil
  511. }
  512. func (w *Windows) Close() {
  513. if w.closed {
  514. return
  515. }
  516. w.closed = true
  517. for id := range w.pages {
  518. _ = w.ClosePage(id)
  519. }
  520. w.environment.release()
  521. w.environment = nil
  522. deadline := time.Now().Add(750 * time.Millisecond)
  523. for pid := range w.processes {
  524. process, err := windows.OpenProcess(windows.SYNCHRONIZE, false, pid)
  525. if err != nil {
  526. continue
  527. }
  528. for time.Now().Before(deadline) {
  529. state, _ := windows.WaitForSingleObject(process, 0)
  530. if state == windows.WAIT_OBJECT_0 {
  531. break
  532. }
  533. _ = w.Pump()
  534. time.Sleep(5 * time.Millisecond)
  535. }
  536. windows.CloseHandle(process)
  537. }
  538. if w.initialized {
  539. windows.CoUninitialize()
  540. w.initialized = false
  541. }
  542. if w.temporary != "" {
  543. _ = os.RemoveAll(w.temporary)
  544. }
  545. }