func launch(mga *Agent) {
js.Global.Set("agent", js.MakeWrapper(mga))
if isBackgroundPage() {
log.Printf("Starting agent")
js.Global.Get("chrome").
Get("runtime").
Get("onConnectExternal").
Call("addListener", func(port *js.Object) {
p := NewAgentPort(port)
go agent.ServeAgent(mga, p)
})
} else if isOptionsPage() {
js.Global.Get("document").
Call("addEventListener", "DOMContentLoaded", func() {
go func() {
textarea := js.Global.Get("document").
Call("getElementById", "keys")
textarea.Set("textContent", mga.PubKeys())
textarea.Get("style").Set("height",
textarea.Get("scrollHeight").String()+"px")
textarea.Call("addEventListener", "click", func() {
textarea.Call("focus")
textarea.Call("select")
})
}()
})
}
}
func GetPlayback(base64Playback string) *js.Object {
var p engine.Playback
buf := bytes.NewReader([]byte(base64Playback))
r := base64.NewDecoder(base64.StdEncoding, buf)
gob.NewDecoder(r).Decode(&p)
return js.MakeWrapper(&p)
}
// Js creates a JS wrapper object for this promise that includes the 'then'
// method required by the Promises/A+ spec.
func (p *Promise) Js() *js.Object {
o := js.MakeWrapper(p)
o.Set("then", func(success, failure *js.Object) *js.Object {
return p.Then(jsCallback(success), jsCallback(failure)).Js()
})
return o
}
func GetReplay(url string) *js.Object {
resp, _ := http.Get(url)
defer resp.Body.Close()
d, _ := ioutil.ReadAll(resp.Body)
msg, _ := capnp.Unmarshal(d)
r, _ := botapi.ReadRootReplay(msg)
return js.MakeWrapper(engine.NewReplay(r))
}
func TestMakeWrapper(t *testing.T) {
m := &M{42}
if !js.Global.Call("eval", `(function(m) { return m.Method({x: 1})["y"] === "z"; })`).Invoke(js.MakeWrapper(m)).Bool() {
t.Fail()
}
if js.MakeWrapper(m).Interface() != m {
t.Fail()
}
f := func(m *M) {
if m.f != 42 {
t.Fail()
}
}
js.Global.Call("eval", `(function(f, m) { f(m); })`).Invoke(f, js.MakeWrapper(m))
}
func (d *Domain) LinkDomain(name string) *js.Object {
n := Domain{
coreDomain: d.coreDomain.LinkDomain(name),
app: d.app,
}
n.wrapped = js.MakeWrapper(&n)
return n.wrapped
}
func main() {
srv := NewServer()
srv.RegisterModule(natural.Module)
srv.RegisterModule(nlparser.Module)
must(srv.EnableModule("natural"))
must(srv.EnableModule("nlparser"))
js.Global.Set("SarifServer", js.MakeWrapper(srv))
}
func (s *Server) NewSocketConn() *js.Object {
conn := s.Broker.NewLocalConn()
sock := &Socket{conn: conn}
sock.object = js.MakeWrapper(sock)
sock.object.Set("send", sock.object.Get("Send"))
sock.object.Set("readyState", 0)
go sock.readLoop()
return sock.object
}
func validate(input *js.Object) *js.Object {
data := js.Global.Get("JSON").Call("stringify", input).String()
var obj interface{}
if err := json.Unmarshal([]byte(data), &obj); err != nil {
panic(err)
}
result := jsonapivalidator.Validate(obj)
return js.MakeWrapper(newJSResult(result))
}
func loginSaved(username, authData string, appkey string, cb *js.Object) {
go func() {
key, _ := base64.StdEncoding.DecodeString(appkey)
data, _ := base64.StdEncoding.DecodeString(authData)
conn, _ := MakeConn()
sController, err := spotcontrol.LoginConnectionSaved(username, data, key, "spotcontrol", conn)
if err != nil {
cb.Invoke(nil, "", "login failed")
}
c := &controllerWrapper{controller: sController}
cb.Invoke(js.MakeWrapper(c), authData, nil)
}()
}
func login(username, password, appkey string, cb *js.Object) {
go func() {
key, _ := base64.StdEncoding.DecodeString(appkey)
conn, _ := MakeConn()
sController, err := spotcontrol.LoginConnection(username, password, key, "spotcontrol", conn)
if err != nil {
cb.Invoke(nil, "", "login failed")
} else {
authData := sController.SavedCredentials
c := &controllerWrapper{controller: sController}
cb.Invoke(js.MakeWrapper(c), base64.StdEncoding.EncodeToString(authData), nil)
}
}()
}
func New(name string) *js.Object {
core.ExternalGenerator = idGenerator{}
a := &App{
registrations: make(map[uint64]*js.Object),
subscriptions: make(map[uint64]*js.Object),
}
d := Domain{
coreDomain: core.NewDomain(name, nil),
app: a,
}
d.wrapped = js.MakeWrapper(&d)
return d.wrapped
}
func init() {
// Create a JavaScript wrapper function that the host can use to invoke the
// HostInitialize function with a WKWebViewBridge
js.Global.Set(
"_GIBWKWebViewBridgeInitialize",
func(message64 *js.Object) {
// Get the messenger object
// NOTE: For some reason, we can't get the postMessage method on
// this object and use Invoke(...) on it directly, it just doesn't
// work. I don't know why, but for some reason doing
// Call("postMessage", ...) does work.
hostMessenger := js.Global.Get(
"webkit",
).Get(
"messageHandlers",
).Get(
"_GIBWKWebViewBridgeMessageHandler",
)
// Create a new WKWebViewBridge
bridge := &WKWebViewBridge{
hostMessenger: hostMessenger,
sequences: newSequencer(),
}
// Create a wrapper for the host to interface with for sending
// results
js.Global.Set("_GIBWKWebViewBridge", js.MakeWrapper(bridge))
// Decode the initialization message
messageBytes, err := base64.StdEncoding.DecodeString(
message64.String(),
)
if err != nil {
panic("unable to decode initialization message")
}
// Call HostInitialize
HostInitialize(bridge, string(messageBytes))
},
)
}
func New() *js.Object {
return js.MakeWrapper(&BibTeX{})
}
func TestMakeWrapper(t *testing.T) {
if !js.Global.Call("eval", `(function(m) { return m.Method({x: 1})["y"] === "z"; })`).Invoke(js.MakeWrapper(&M{42})).Bool() {
t.Fail()
}
}
func (p *Playback) Board(i int) *js.Object {
return js.MakeWrapper(p.Boards[i])
}
func RiveScript() *js.Object {
return js.MakeWrapper(rivescript.New())
}
func New(name string) *js.Object {
return js.MakeWrapper(&Pet{name})
}
func UGCPolicy(name string) *js.Object {
return js.MakeWrapper(bluemonday.UGCPolicy())
}
func GetReplayFromString(replayString string) *js.Object {
// Will it work? It's not Unicode clean
msg, _ := capnp.Unmarshal([]byte(replayString))
r, _ := botapi.ReadRootReplay(msg)
return js.MakeWrapper(engine.NewReplay(r))
}
