123 lines
3.1 KiB
Go
123 lines
3.1 KiB
Go
package playwright
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
type channelOwner struct {
|
|
sync.RWMutex
|
|
eventEmitter
|
|
objectType string
|
|
guid string
|
|
channel *channel
|
|
objects map[string]*channelOwner
|
|
eventToSubscriptionMapping map[string]string
|
|
connection *connection
|
|
initializer map[string]interface{}
|
|
parent *channelOwner
|
|
wasCollected bool
|
|
isInternalType bool
|
|
}
|
|
|
|
func (c *channelOwner) dispose(reason ...string) {
|
|
// Clean up from parent and connection.
|
|
if c.parent != nil {
|
|
delete(c.parent.objects, c.guid)
|
|
}
|
|
c.connection.objects.Delete(c.guid)
|
|
if len(reason) > 0 {
|
|
c.wasCollected = reason[0] == "gc"
|
|
}
|
|
|
|
// Dispose all children.
|
|
for _, object := range c.objects {
|
|
object.dispose(reason...)
|
|
}
|
|
c.objects = make(map[string]*channelOwner)
|
|
}
|
|
|
|
func (c *channelOwner) adopt(child *channelOwner) {
|
|
delete(child.parent.objects, child.guid)
|
|
c.objects[child.guid] = child
|
|
child.parent = c
|
|
}
|
|
|
|
func (c *channelOwner) setEventSubscriptionMapping(mapping map[string]string) {
|
|
c.eventToSubscriptionMapping = mapping
|
|
}
|
|
|
|
func (c *channelOwner) updateSubscription(event string, enabled bool) {
|
|
protocolEvent, ok := c.eventToSubscriptionMapping[event]
|
|
if ok {
|
|
c.channel.SendNoReplyInternal("updateSubscription", map[string]interface{}{
|
|
"event": protocolEvent,
|
|
"enabled": enabled,
|
|
})
|
|
}
|
|
}
|
|
|
|
func (c *channelOwner) Once(name string, handler interface{}) {
|
|
c.addEvent(name, handler, true)
|
|
}
|
|
|
|
func (c *channelOwner) On(name string, handler interface{}) {
|
|
c.addEvent(name, handler, false)
|
|
}
|
|
|
|
func (c *channelOwner) addEvent(name string, handler interface{}, once bool) {
|
|
if c.ListenerCount(name) == 0 {
|
|
c.updateSubscription(name, true)
|
|
}
|
|
c.eventEmitter.addEvent(name, handler, once)
|
|
}
|
|
|
|
func (c *channelOwner) RemoveListener(name string, handler interface{}) {
|
|
c.eventEmitter.RemoveListener(name, handler)
|
|
if c.ListenerCount(name) == 0 {
|
|
c.updateSubscription(name, false)
|
|
}
|
|
}
|
|
|
|
func (c *channelOwner) createChannelOwner(self interface{}, parent *channelOwner, objectType string, guid string, initializer map[string]interface{}) {
|
|
c.objectType = objectType
|
|
c.guid = guid
|
|
c.wasCollected = false
|
|
c.parent = parent
|
|
c.objects = make(map[string]*channelOwner)
|
|
c.initializer = initializer
|
|
if c.parent != nil {
|
|
c.connection = parent.connection
|
|
c.parent.objects[guid] = c
|
|
}
|
|
if c.connection != nil {
|
|
c.connection.objects.Store(guid, c)
|
|
}
|
|
c.channel = newChannel(c, self)
|
|
c.eventToSubscriptionMapping = map[string]string{}
|
|
}
|
|
|
|
func (c *channelOwner) markAsInternalType() {
|
|
c.isInternalType = true
|
|
}
|
|
|
|
type rootChannelOwner struct {
|
|
channelOwner
|
|
}
|
|
|
|
func (r *rootChannelOwner) initialize() (*Playwright, error) {
|
|
ret, err := r.channel.SendReturnAsDict("initialize", map[string]interface{}{
|
|
"sdkLanguage": "javascript",
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return fromChannel(ret["playwright"]).(*Playwright), nil
|
|
}
|
|
|
|
func newRootChannelOwner(connection *connection) *rootChannelOwner {
|
|
c := &rootChannelOwner{}
|
|
c.connection = connection
|
|
c.createChannelOwner(c, nil, "Root", "", make(map[string]interface{}))
|
|
return c
|
|
}
|