summaryrefslogtreecommitdiff
path: root/vendor/github.com/playwright-community/playwright-go/browser_context.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/playwright-community/playwright-go/browser_context.go')
-rw-r--r--vendor/github.com/playwright-community/playwright-go/browser_context.go914
1 files changed, 914 insertions, 0 deletions
diff --git a/vendor/github.com/playwright-community/playwright-go/browser_context.go b/vendor/github.com/playwright-community/playwright-go/browser_context.go
new file mode 100644
index 0000000..1d420d3
--- /dev/null
+++ b/vendor/github.com/playwright-community/playwright-go/browser_context.go
@@ -0,0 +1,914 @@
+package playwright
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "os"
+ "regexp"
+ "slices"
+ "strings"
+ "sync"
+
+ "github.com/playwright-community/playwright-go/internal/safe"
+)
+
+type browserContextImpl struct {
+ channelOwner
+ timeoutSettings *timeoutSettings
+ closeWasCalled bool
+ options *BrowserNewContextOptions
+ pages []Page
+ routes []*routeHandlerEntry
+ webSocketRoutes []*webSocketRouteHandler
+ ownedPage Page
+ browser *browserImpl
+ serviceWorkers []Worker
+ backgroundPages []Page
+ bindings *safe.SyncMap[string, BindingCallFunction]
+ tracing *tracingImpl
+ request *apiRequestContextImpl
+ harRecorders map[string]harRecordingMetadata
+ closed chan struct{}
+ closeReason *string
+ harRouters []*harRouter
+ clock Clock
+}
+
+func (b *browserContextImpl) Clock() Clock {
+ return b.clock
+}
+
+func (b *browserContextImpl) SetDefaultNavigationTimeout(timeout float64) {
+ b.setDefaultNavigationTimeoutImpl(&timeout)
+}
+
+func (b *browserContextImpl) setDefaultNavigationTimeoutImpl(timeout *float64) {
+ b.timeoutSettings.SetDefaultNavigationTimeout(timeout)
+ b.channel.SendNoReplyInternal("setDefaultNavigationTimeoutNoReply", map[string]interface{}{
+ "timeout": timeout,
+ })
+}
+
+func (b *browserContextImpl) SetDefaultTimeout(timeout float64) {
+ b.setDefaultTimeoutImpl(&timeout)
+}
+
+func (b *browserContextImpl) setDefaultTimeoutImpl(timeout *float64) {
+ b.timeoutSettings.SetDefaultTimeout(timeout)
+ b.channel.SendNoReplyInternal("setDefaultTimeoutNoReply", map[string]interface{}{
+ "timeout": timeout,
+ })
+}
+
+func (b *browserContextImpl) Pages() []Page {
+ b.Lock()
+ defer b.Unlock()
+ return b.pages
+}
+
+func (b *browserContextImpl) Browser() Browser {
+ return b.browser
+}
+
+func (b *browserContextImpl) Tracing() Tracing {
+ return b.tracing
+}
+
+func (b *browserContextImpl) NewCDPSession(page interface{}) (CDPSession, error) {
+ params := map[string]interface{}{}
+
+ if p, ok := page.(*pageImpl); ok {
+ params["page"] = p.channel
+ } else if f, ok := page.(*frameImpl); ok {
+ params["frame"] = f.channel
+ } else {
+ return nil, fmt.Errorf("not page or frame: %v", page)
+ }
+
+ channel, err := b.channel.Send("newCDPSession", params)
+ if err != nil {
+ return nil, err
+ }
+
+ cdpSession := fromChannel(channel).(*cdpSessionImpl)
+
+ return cdpSession, nil
+}
+
+func (b *browserContextImpl) NewPage() (Page, error) {
+ if b.ownedPage != nil {
+ return nil, errors.New("Please use browser.NewContext()")
+ }
+ channel, err := b.channel.Send("newPage")
+ if err != nil {
+ return nil, err
+ }
+ return fromChannel(channel).(*pageImpl), nil
+}
+
+func (b *browserContextImpl) Cookies(urls ...string) ([]Cookie, error) {
+ result, err := b.channel.Send("cookies", map[string]interface{}{
+ "urls": urls,
+ })
+ if err != nil {
+ return nil, err
+ }
+ cookies := make([]Cookie, len(result.([]interface{})))
+ for i, item := range result.([]interface{}) {
+ cookie := &Cookie{}
+ remapMapToStruct(item, cookie)
+ cookies[i] = *cookie
+ }
+ return cookies, nil
+}
+
+func (b *browserContextImpl) AddCookies(cookies []OptionalCookie) error {
+ _, err := b.channel.Send("addCookies", map[string]interface{}{
+ "cookies": cookies,
+ })
+ return err
+}
+
+func (b *browserContextImpl) ClearCookies(options ...BrowserContextClearCookiesOptions) error {
+ params := map[string]interface{}{}
+ if len(options) == 1 {
+ if options[0].Domain != nil {
+ switch t := options[0].Domain.(type) {
+ case string:
+ params["domain"] = t
+ case *string:
+ params["domain"] = t
+ case *regexp.Regexp:
+ pattern, flag := convertRegexp(t)
+ params["domainRegexSource"] = pattern
+ params["domainRegexFlags"] = flag
+ default:
+ return errors.New("invalid type for domain, expected string or *regexp.Regexp")
+ }
+ }
+ if options[0].Name != nil {
+ switch t := options[0].Name.(type) {
+ case string:
+ params["name"] = t
+ case *string:
+ params["name"] = t
+ case *regexp.Regexp:
+ pattern, flag := convertRegexp(t)
+ params["nameRegexSource"] = pattern
+ params["nameRegexFlags"] = flag
+ default:
+ return errors.New("invalid type for name, expected string or *regexp.Regexp")
+ }
+ }
+ if options[0].Path != nil {
+ switch t := options[0].Path.(type) {
+ case string:
+ params["path"] = t
+ case *string:
+ params["path"] = t
+ case *regexp.Regexp:
+ pattern, flag := convertRegexp(t)
+ params["pathRegexSource"] = pattern
+ params["pathRegexFlags"] = flag
+ default:
+ return errors.New("invalid type for path, expected string or *regexp.Regexp")
+ }
+ }
+ }
+ _, err := b.channel.Send("clearCookies", params)
+ return err
+}
+
+func (b *browserContextImpl) GrantPermissions(permissions []string, options ...BrowserContextGrantPermissionsOptions) error {
+ _, err := b.channel.Send("grantPermissions", map[string]interface{}{
+ "permissions": permissions,
+ }, options)
+ return err
+}
+
+func (b *browserContextImpl) ClearPermissions() error {
+ _, err := b.channel.Send("clearPermissions")
+ return err
+}
+
+func (b *browserContextImpl) SetGeolocation(geolocation *Geolocation) error {
+ _, err := b.channel.Send("setGeolocation", map[string]interface{}{
+ "geolocation": geolocation,
+ })
+ return err
+}
+
+func (b *browserContextImpl) ResetGeolocation() error {
+ _, err := b.channel.Send("setGeolocation", map[string]interface{}{})
+ return err
+}
+
+func (b *browserContextImpl) SetExtraHTTPHeaders(headers map[string]string) error {
+ _, err := b.channel.Send("setExtraHTTPHeaders", map[string]interface{}{
+ "headers": serializeMapToNameAndValue(headers),
+ })
+ return err
+}
+
+func (b *browserContextImpl) SetOffline(offline bool) error {
+ _, err := b.channel.Send("setOffline", map[string]interface{}{
+ "offline": offline,
+ })
+ return err
+}
+
+func (b *browserContextImpl) AddInitScript(script Script) error {
+ var source string
+ if script.Content != nil {
+ source = *script.Content
+ }
+ if script.Path != nil {
+ content, err := os.ReadFile(*script.Path)
+ if err != nil {
+ return err
+ }
+ source = string(content)
+ }
+ _, err := b.channel.Send("addInitScript", map[string]interface{}{
+ "source": source,
+ })
+ return err
+}
+
+func (b *browserContextImpl) ExposeBinding(name string, binding BindingCallFunction, handle ...bool) error {
+ needsHandle := false
+ if len(handle) == 1 {
+ needsHandle = handle[0]
+ }
+ for _, page := range b.Pages() {
+ if _, ok := page.(*pageImpl).bindings.Load(name); ok {
+ return fmt.Errorf("Function '%s' has been already registered in one of the pages", name)
+ }
+ }
+ if _, ok := b.bindings.Load(name); ok {
+ return fmt.Errorf("Function '%s' has been already registered", name)
+ }
+ _, err := b.channel.Send("exposeBinding", map[string]interface{}{
+ "name": name,
+ "needsHandle": needsHandle,
+ })
+ if err != nil {
+ return err
+ }
+ b.bindings.Store(name, binding)
+ return err
+}
+
+func (b *browserContextImpl) ExposeFunction(name string, binding ExposedFunction) error {
+ return b.ExposeBinding(name, func(source *BindingSource, args ...interface{}) interface{} {
+ return binding(args...)
+ })
+}
+
+func (b *browserContextImpl) Route(url interface{}, handler routeHandler, times ...int) error {
+ b.Lock()
+ defer b.Unlock()
+ b.routes = slices.Insert(b.routes, 0, newRouteHandlerEntry(newURLMatcher(url, b.options.BaseURL), handler, times...))
+ return b.updateInterceptionPatterns()
+}
+
+func (b *browserContextImpl) Unroute(url interface{}, handlers ...routeHandler) error {
+ removed, remaining, err := unroute(b.routes, url, handlers...)
+ if err != nil {
+ return err
+ }
+ return b.unrouteInternal(removed, remaining, UnrouteBehaviorDefault)
+}
+
+func (b *browserContextImpl) unrouteInternal(removed []*routeHandlerEntry, remaining []*routeHandlerEntry, behavior *UnrouteBehavior) error {
+ b.Lock()
+ defer b.Unlock()
+ b.routes = remaining
+ if err := b.updateInterceptionPatterns(); err != nil {
+ return err
+ }
+ if behavior == nil || behavior == UnrouteBehaviorDefault {
+ return nil
+ }
+ wg := &sync.WaitGroup{}
+ for _, entry := range removed {
+ wg.Add(1)
+ go func(entry *routeHandlerEntry) {
+ defer wg.Done()
+ entry.Stop(string(*behavior))
+ }(entry)
+ }
+ wg.Wait()
+ return nil
+}
+
+func (b *browserContextImpl) UnrouteAll(options ...BrowserContextUnrouteAllOptions) error {
+ var behavior *UnrouteBehavior
+ if len(options) == 1 {
+ behavior = options[0].Behavior
+ }
+ defer b.disposeHarRouters()
+ return b.unrouteInternal(b.routes, []*routeHandlerEntry{}, behavior)
+}
+
+func (b *browserContextImpl) disposeHarRouters() {
+ for _, router := range b.harRouters {
+ router.dispose()
+ }
+ b.harRouters = make([]*harRouter, 0)
+}
+
+func (b *browserContextImpl) Request() APIRequestContext {
+ return b.request
+}
+
+func (b *browserContextImpl) RouteFromHAR(har string, options ...BrowserContextRouteFromHAROptions) error {
+ opt := BrowserContextRouteFromHAROptions{}
+ if len(options) == 1 {
+ opt = options[0]
+ }
+ if opt.Update != nil && *opt.Update {
+ var updateContent *HarContentPolicy
+ switch opt.UpdateContent {
+ case RouteFromHarUpdateContentPolicyAttach:
+ updateContent = HarContentPolicyAttach
+ case RouteFromHarUpdateContentPolicyEmbed:
+ updateContent = HarContentPolicyEmbed
+ }
+ return b.recordIntoHar(har, browserContextRecordIntoHarOptions{
+ URL: opt.URL,
+ UpdateContent: updateContent,
+ UpdateMode: opt.UpdateMode,
+ })
+ }
+ notFound := opt.NotFound
+ if notFound == nil {
+ notFound = HarNotFoundAbort
+ }
+ router := newHarRouter(b.connection.localUtils, har, *notFound, opt.URL)
+ b.harRouters = append(b.harRouters, router)
+ return router.addContextRoute(b)
+}
+
+func (b *browserContextImpl) WaitForEvent(event string, options ...BrowserContextWaitForEventOptions) (interface{}, error) {
+ return b.waiterForEvent(event, options...).Wait()
+}
+
+func (b *browserContextImpl) waiterForEvent(event string, options ...BrowserContextWaitForEventOptions) *waiter {
+ timeout := b.timeoutSettings.Timeout()
+ var predicate interface{} = nil
+ if len(options) == 1 {
+ if options[0].Timeout != nil {
+ timeout = *options[0].Timeout
+ }
+ predicate = options[0].Predicate
+ }
+ waiter := newWaiter().WithTimeout(timeout)
+ waiter.RejectOnEvent(b, "close", ErrTargetClosed)
+ return waiter.WaitForEvent(b, event, predicate)
+}
+
+func (b *browserContextImpl) ExpectConsoleMessage(cb func() error, options ...BrowserContextExpectConsoleMessageOptions) (ConsoleMessage, error) {
+ var w *waiter
+ if len(options) == 1 {
+ w = b.waiterForEvent("console", BrowserContextWaitForEventOptions{
+ Predicate: options[0].Predicate,
+ Timeout: options[0].Timeout,
+ })
+ } else {
+ w = b.waiterForEvent("console")
+ }
+ ret, err := w.RunAndWait(cb)
+ if err != nil {
+ return nil, err
+ }
+ return ret.(ConsoleMessage), nil
+}
+
+func (b *browserContextImpl) ExpectEvent(event string, cb func() error, options ...BrowserContextExpectEventOptions) (interface{}, error) {
+ if len(options) == 1 {
+ return b.waiterForEvent(event, BrowserContextWaitForEventOptions(options[0])).RunAndWait(cb)
+ }
+ return b.waiterForEvent(event).RunAndWait(cb)
+}
+
+func (b *browserContextImpl) ExpectPage(cb func() error, options ...BrowserContextExpectPageOptions) (Page, error) {
+ var w *waiter
+ if len(options) == 1 {
+ w = b.waiterForEvent("page", BrowserContextWaitForEventOptions{
+ Predicate: options[0].Predicate,
+ Timeout: options[0].Timeout,
+ })
+ } else {
+ w = b.waiterForEvent("page")
+ }
+ ret, err := w.RunAndWait(cb)
+ if err != nil {
+ return nil, err
+ }
+ return ret.(Page), nil
+}
+
+func (b *browserContextImpl) Close(options ...BrowserContextCloseOptions) error {
+ if b.closeWasCalled {
+ return nil
+ }
+ if len(options) == 1 {
+ b.closeReason = options[0].Reason
+ }
+ b.closeWasCalled = true
+
+ _, err := b.channel.connection.WrapAPICall(func() (interface{}, error) {
+ return nil, b.request.Dispose(APIRequestContextDisposeOptions{
+ Reason: b.closeReason,
+ })
+ }, true)
+ if err != nil {
+ return err
+ }
+
+ innerClose := func() (interface{}, error) {
+ for harId, harMetaData := range b.harRecorders {
+ overrides := map[string]interface{}{}
+ if harId != "" {
+ overrides["harId"] = harId
+ }
+ response, err := b.channel.Send("harExport", overrides)
+ if err != nil {
+ return nil, err
+ }
+ artifact := fromChannel(response).(*artifactImpl)
+ // Server side will compress artifact if content is attach or if file is .zip.
+ needCompressed := strings.HasSuffix(strings.ToLower(harMetaData.Path), ".zip")
+ if !needCompressed && harMetaData.Content == HarContentPolicyAttach {
+ tmpPath := harMetaData.Path + ".tmp"
+ if err := artifact.SaveAs(tmpPath); err != nil {
+ return nil, err
+ }
+ err = b.connection.localUtils.HarUnzip(tmpPath, harMetaData.Path)
+ if err != nil {
+ return nil, err
+ }
+ } else {
+ if err := artifact.SaveAs(harMetaData.Path); err != nil {
+ return nil, err
+ }
+ }
+ if err := artifact.Delete(); err != nil {
+ return nil, err
+ }
+ }
+ return nil, nil
+ }
+
+ _, err = b.channel.connection.WrapAPICall(innerClose, true)
+ if err != nil {
+ return err
+ }
+
+ _, err = b.channel.Send("close", map[string]interface{}{
+ "reason": b.closeReason,
+ })
+ if err != nil {
+ return err
+ }
+ <-b.closed
+ return err
+}
+
+type browserContextRecordIntoHarOptions struct {
+ Page Page
+ URL interface{}
+ UpdateContent *HarContentPolicy
+ UpdateMode *HarMode
+}
+
+func (b *browserContextImpl) recordIntoHar(har string, options ...browserContextRecordIntoHarOptions) error {
+ overrides := map[string]interface{}{}
+ harOptions := recordHarInputOptions{
+ Path: har,
+ Content: HarContentPolicyAttach,
+ Mode: HarModeMinimal,
+ }
+ if len(options) == 1 {
+ if options[0].UpdateContent != nil {
+ harOptions.Content = options[0].UpdateContent
+ }
+ if options[0].UpdateMode != nil {
+ harOptions.Mode = options[0].UpdateMode
+ }
+ harOptions.URL = options[0].URL
+ overrides["options"] = prepareRecordHarOptions(harOptions)
+ if options[0].Page != nil {
+ overrides["page"] = options[0].Page.(*pageImpl).channel
+ }
+ }
+ harId, err := b.channel.Send("harStart", overrides)
+ if err != nil {
+ return err
+ }
+ b.harRecorders[harId.(string)] = harRecordingMetadata{
+ Path: har,
+ Content: harOptions.Content,
+ }
+ return nil
+}
+
+func (b *browserContextImpl) StorageState(paths ...string) (*StorageState, error) {
+ result, err := b.channel.SendReturnAsDict("storageState")
+ if err != nil {
+ return nil, err
+ }
+ if len(paths) == 1 {
+ file, err := os.Create(paths[0])
+ if err != nil {
+ return nil, err
+ }
+ if err := json.NewEncoder(file).Encode(result); err != nil {
+ return nil, err
+ }
+ if err := file.Close(); err != nil {
+ return nil, err
+ }
+ }
+ var storageState StorageState
+ remapMapToStruct(result, &storageState)
+ return &storageState, nil
+}
+
+func (b *browserContextImpl) onBinding(binding *bindingCallImpl) {
+ function, ok := b.bindings.Load(binding.initializer["name"].(string))
+ if !ok || function == nil {
+ return
+ }
+ go binding.Call(function)
+}
+
+func (b *browserContextImpl) onClose() {
+ if b.browser != nil {
+ contexts := make([]BrowserContext, 0)
+ b.browser.Lock()
+ for _, context := range b.browser.contexts {
+ if context != b {
+ contexts = append(contexts, context)
+ }
+ }
+ b.browser.contexts = contexts
+ b.browser.Unlock()
+ }
+ b.disposeHarRouters()
+ b.Emit("close", b)
+}
+
+func (b *browserContextImpl) onPage(page Page) {
+ b.Lock()
+ b.pages = append(b.pages, page)
+ b.Unlock()
+ b.Emit("page", page)
+ opener, _ := page.Opener()
+ if opener != nil && !opener.IsClosed() {
+ opener.Emit("popup", page)
+ }
+}
+
+func (b *browserContextImpl) onRoute(route *routeImpl) {
+ b.Lock()
+ route.context = b
+ page := route.Request().(*requestImpl).safePage()
+ routes := make([]*routeHandlerEntry, len(b.routes))
+ copy(routes, b.routes)
+ b.Unlock()
+
+ checkInterceptionIfNeeded := func() {
+ b.Lock()
+ defer b.Unlock()
+ if len(b.routes) == 0 {
+ _, err := b.connection.WrapAPICall(func() (interface{}, error) {
+ err := b.updateInterceptionPatterns()
+ return nil, err
+ }, true)
+ if err != nil {
+ logger.Error("could not update interception patterns", "error", err)
+ }
+ }
+ }
+
+ url := route.Request().URL()
+ for _, handlerEntry := range routes {
+ // If the page or the context was closed we stall all requests right away.
+ if (page != nil && page.closeWasCalled) || b.closeWasCalled {
+ return
+ }
+ if !handlerEntry.Matches(url) {
+ continue
+ }
+ if !slices.ContainsFunc(b.routes, func(entry *routeHandlerEntry) bool {
+ return entry == handlerEntry
+ }) {
+ continue
+ }
+ if handlerEntry.WillExceed() {
+ b.routes = slices.DeleteFunc(b.routes, func(rhe *routeHandlerEntry) bool {
+ return rhe == handlerEntry
+ })
+ }
+ handled := handlerEntry.Handle(route)
+ checkInterceptionIfNeeded()
+ yes := <-handled
+ if yes {
+ return
+ }
+ }
+ // If the page is closed or unrouteAll() was called without waiting and interception disabled,
+ // the method will throw an error - silence it.
+ _ = route.internalContinue(true)
+}
+
+func (b *browserContextImpl) updateInterceptionPatterns() error {
+ patterns := prepareInterceptionPatterns(b.routes)
+ _, err := b.channel.Send("setNetworkInterceptionPatterns", map[string]interface{}{
+ "patterns": patterns,
+ })
+ return err
+}
+
+func (b *browserContextImpl) pause() <-chan error {
+ ret := make(chan error, 1)
+ go func() {
+ _, err := b.channel.Send("pause")
+ ret <- err
+ }()
+ return ret
+}
+
+func (b *browserContextImpl) onBackgroundPage(ev map[string]interface{}) {
+ b.Lock()
+ p := fromChannel(ev["page"]).(*pageImpl)
+ p.browserContext = b
+ b.backgroundPages = append(b.backgroundPages, p)
+ b.Unlock()
+ b.Emit("backgroundpage", p)
+}
+
+func (b *browserContextImpl) onServiceWorker(worker *workerImpl) {
+ worker.context = b
+ b.serviceWorkers = append(b.serviceWorkers, worker)
+ b.Emit("serviceworker", worker)
+}
+
+func (b *browserContextImpl) setOptions(options *BrowserNewContextOptions, tracesDir *string) {
+ if options == nil {
+ options = &BrowserNewContextOptions{}
+ }
+ b.options = options
+ if b.options != nil && b.options.RecordHarPath != nil {
+ b.harRecorders[""] = harRecordingMetadata{
+ Path: *b.options.RecordHarPath,
+ Content: b.options.RecordHarContent,
+ }
+ }
+ if tracesDir != nil {
+ b.tracing.tracesDir = *tracesDir
+ }
+}
+
+func (b *browserContextImpl) BackgroundPages() []Page {
+ b.Lock()
+ defer b.Unlock()
+ return b.backgroundPages
+}
+
+func (b *browserContextImpl) ServiceWorkers() []Worker {
+ b.Lock()
+ defer b.Unlock()
+ return b.serviceWorkers
+}
+
+func (b *browserContextImpl) OnBackgroundPage(fn func(Page)) {
+ b.On("backgroundpage", fn)
+}
+
+func (b *browserContextImpl) OnClose(fn func(BrowserContext)) {
+ b.On("close", fn)
+}
+
+func (b *browserContextImpl) OnConsole(fn func(ConsoleMessage)) {
+ b.On("console", fn)
+}
+
+func (b *browserContextImpl) OnDialog(fn func(Dialog)) {
+ b.On("dialog", fn)
+}
+
+func (b *browserContextImpl) OnPage(fn func(Page)) {
+ b.On("page", fn)
+}
+
+func (b *browserContextImpl) OnRequest(fn func(Request)) {
+ b.On("request", fn)
+}
+
+func (b *browserContextImpl) OnRequestFailed(fn func(Request)) {
+ b.On("requestfailed", fn)
+}
+
+func (b *browserContextImpl) OnRequestFinished(fn func(Request)) {
+ b.On("requestfinished", fn)
+}
+
+func (b *browserContextImpl) OnResponse(fn func(Response)) {
+ b.On("response", fn)
+}
+
+func (b *browserContextImpl) OnWebError(fn func(WebError)) {
+ b.On("weberror", fn)
+}
+
+func (b *browserContextImpl) RouteWebSocket(url interface{}, handler func(WebSocketRoute)) error {
+ b.Lock()
+ defer b.Unlock()
+ b.webSocketRoutes = slices.Insert(b.webSocketRoutes, 0, newWebSocketRouteHandler(newURLMatcher(url, b.options.BaseURL), handler))
+
+ return b.updateWebSocketInterceptionPatterns()
+}
+
+func (b *browserContextImpl) onWebSocketRoute(wr WebSocketRoute) {
+ b.Lock()
+ index := slices.IndexFunc(b.webSocketRoutes, func(r *webSocketRouteHandler) bool {
+ return r.Matches(wr.URL())
+ })
+ if index == -1 {
+ b.Unlock()
+ _, err := wr.ConnectToServer()
+ if err != nil {
+ logger.Error("could not connect to WebSocket server", "error", err)
+ }
+ return
+ }
+ handler := b.webSocketRoutes[index]
+ b.Unlock()
+ handler.Handle(wr)
+}
+
+func (b *browserContextImpl) updateWebSocketInterceptionPatterns() error {
+ patterns := prepareWebSocketRouteHandlerInterceptionPatterns(b.webSocketRoutes)
+ _, err := b.channel.Send("setWebSocketInterceptionPatterns", map[string]interface{}{
+ "patterns": patterns,
+ })
+ return err
+}
+
+func (b *browserContextImpl) effectiveCloseReason() *string {
+ b.Lock()
+ defer b.Unlock()
+ if b.closeReason != nil {
+ return b.closeReason
+ }
+ if b.browser != nil {
+ return b.browser.closeReason
+ }
+ return nil
+}
+
+func newBrowserContext(parent *channelOwner, objectType string, guid string, initializer map[string]interface{}) *browserContextImpl {
+ bt := &browserContextImpl{
+ timeoutSettings: newTimeoutSettings(nil),
+ pages: make([]Page, 0),
+ backgroundPages: make([]Page, 0),
+ routes: make([]*routeHandlerEntry, 0),
+ bindings: safe.NewSyncMap[string, BindingCallFunction](),
+ harRecorders: make(map[string]harRecordingMetadata),
+ closed: make(chan struct{}, 1),
+ harRouters: make([]*harRouter, 0),
+ }
+ bt.createChannelOwner(bt, parent, objectType, guid, initializer)
+ if parent.objectType == "Browser" {
+ bt.browser = fromChannel(parent.channel).(*browserImpl)
+ bt.browser.contexts = append(bt.browser.contexts, bt)
+ }
+ bt.tracing = fromChannel(initializer["tracing"]).(*tracingImpl)
+ bt.request = fromChannel(initializer["requestContext"]).(*apiRequestContextImpl)
+ bt.clock = newClock(bt)
+ bt.channel.On("bindingCall", func(params map[string]interface{}) {
+ bt.onBinding(fromChannel(params["binding"]).(*bindingCallImpl))
+ })
+
+ bt.channel.On("close", bt.onClose)
+ bt.channel.On("page", func(payload map[string]interface{}) {
+ bt.onPage(fromChannel(payload["page"]).(*pageImpl))
+ })
+ bt.channel.On("route", func(params map[string]interface{}) {
+ bt.channel.CreateTask(func() {
+ bt.onRoute(fromChannel(params["route"]).(*routeImpl))
+ })
+ })
+ bt.channel.On("webSocketRoute", func(params map[string]interface{}) {
+ bt.channel.CreateTask(func() {
+ bt.onWebSocketRoute(fromChannel(params["webSocketRoute"]).(*webSocketRouteImpl))
+ })
+ })
+ bt.channel.On("backgroundPage", bt.onBackgroundPage)
+ bt.channel.On("serviceWorker", func(params map[string]interface{}) {
+ bt.onServiceWorker(fromChannel(params["worker"]).(*workerImpl))
+ })
+ bt.channel.On("console", func(ev map[string]interface{}) {
+ message := newConsoleMessage(ev)
+ bt.Emit("console", message)
+ if message.page != nil {
+ message.page.Emit("console", message)
+ }
+ })
+ bt.channel.On("dialog", func(params map[string]interface{}) {
+ dialog := fromChannel(params["dialog"]).(*dialogImpl)
+ go func() {
+ hasListeners := bt.Emit("dialog", dialog)
+ page := dialog.page
+ if page != nil {
+ if page.Emit("dialog", dialog) {
+ hasListeners = true
+ }
+ }
+ if !hasListeners {
+ // Although we do similar handling on the server side, we still need this logic
+ // on the client side due to a possible race condition between two async calls:
+ // a) removing "dialog" listener subscription (client->server)
+ // b) actual "dialog" event (server->client)
+ if dialog.Type() == "beforeunload" {
+ _ = dialog.Accept()
+ } else {
+ _ = dialog.Dismiss()
+ }
+ }
+ }()
+ })
+ bt.channel.On(
+ "pageError", func(ev map[string]interface{}) {
+ pwErr := &Error{}
+ remapMapToStruct(ev["error"].(map[string]interface{})["error"], pwErr)
+ err := parseError(*pwErr)
+ page := fromNullableChannel(ev["page"])
+ if page != nil {
+ bt.Emit("weberror", newWebError(page.(*pageImpl), err))
+ page.(*pageImpl).Emit("pageerror", err)
+ } else {
+ bt.Emit("weberror", newWebError(nil, err))
+ }
+ },
+ )
+ bt.channel.On("request", func(ev map[string]interface{}) {
+ request := fromChannel(ev["request"]).(*requestImpl)
+ page := fromNullableChannel(ev["page"])
+ bt.Emit("request", request)
+ if page != nil {
+ page.(*pageImpl).Emit("request", request)
+ }
+ })
+ bt.channel.On("requestFailed", func(ev map[string]interface{}) {
+ request := fromChannel(ev["request"]).(*requestImpl)
+ failureText := ev["failureText"]
+ if failureText != nil {
+ request.failureText = failureText.(string)
+ }
+ page := fromNullableChannel(ev["page"])
+ request.setResponseEndTiming(ev["responseEndTiming"].(float64))
+ bt.Emit("requestfailed", request)
+ if page != nil {
+ page.(*pageImpl).Emit("requestfailed", request)
+ }
+ })
+
+ bt.channel.On("requestFinished", func(ev map[string]interface{}) {
+ request := fromChannel(ev["request"]).(*requestImpl)
+ response := fromNullableChannel(ev["response"])
+ page := fromNullableChannel(ev["page"])
+ request.setResponseEndTiming(ev["responseEndTiming"].(float64))
+ bt.Emit("requestfinished", request)
+ if page != nil {
+ page.(*pageImpl).Emit("requestfinished", request)
+ }
+ if response != nil {
+ close(response.(*responseImpl).finished)
+ }
+ })
+ bt.channel.On("response", func(ev map[string]interface{}) {
+ response := fromChannel(ev["response"]).(*responseImpl)
+ page := fromNullableChannel(ev["page"])
+ bt.Emit("response", response)
+ if page != nil {
+ page.(*pageImpl).Emit("response", response)
+ }
+ })
+ bt.Once("close", func() {
+ bt.closed <- struct{}{}
+ })
+ bt.setEventSubscriptionMapping(map[string]string{
+ "console": "console",
+ "dialog": "dialog",
+ "request": "request",
+ "response": "response",
+ "requestfinished": "requestFinished",
+ "responsefailed": "responseFailed",
+ })
+ return bt
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-02 04:28:39 +0000