blob: 2ae4f979b43751690100121c6eedd643ea40383d [file] [log] [blame]
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package application
import (
"log"
"sync"
"mojo/public/go/bindings"
"mojo/public/go/system"
"mojo/public/interfaces/application/application"
sp "mojo/public/interfaces/application/service_provider"
"mojo/public/interfaces/application/shell"
)
// Delegate is an interface that your mojo application should implement.
// All methods are called from the same goroutine to make sure that order of
// calls matches the order of messages sent to underlying message pipe.
type Delegate interface {
// Initialize is called exactly once before any other method.
Initialize(ctx Context)
// AcceptConnection is called when another application attempts to open
// a connection to this application. Close the connection if you no
// longer need it.
AcceptConnection(connection *Connection)
// Quit is called to request the application shut itself down
// gracefully.
Quit()
}
// Context is an interface to information about mojo application environment.
type Context interface {
// URL returns the URL the application was found at, after all mappings,
// resolution, and redirects.
URL() string
// Args returns a list of initial configuration arguments, passed by the
// Shell.
Args() []string
// ConnectToApplication requests a new connection to an application.
ConnectToApplication(remoteURL string) *OutgoingConnection
// Close closes the main run loop for this application.
Close()
}
// ApplicationImpl is an utility class for communicating with the Shell, and
// providing Services to clients.
type ApplicationImpl struct {
shell *shell.Shell_Proxy
args []string
url string
// Pointer to the stub that runs this instance of ApplicationImpl.
runner *bindings.Stub
quitOnce sync.Once
delegate Delegate
// Protects connections, that can be modified concurrently because of
// ConnectToApplication calls.
mu sync.Mutex
connections []*Connection
}
// Run binds your mojo application to provided message pipe handle and runs it
// until the application is terminated.
func Run(delegate Delegate, applicationRequest system.MojoHandle) {
messagePipe := system.GetCore().AcquireNativeHandle(applicationRequest).ToMessagePipeHandle()
appRequest := application.Application_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
impl := &ApplicationImpl{
delegate: delegate,
}
stub := application.NewApplicationStub(appRequest, impl, bindings.GetAsyncWaiter())
impl.runner = stub
for {
if err := stub.ServeRequest(); err != nil {
connectionError, ok := err.(*bindings.ConnectionError)
if !ok || !connectionError.Closed() {
log.Println(err)
}
impl.RequestQuit()
break
}
}
}
// Mojo application implementation.
func (impl *ApplicationImpl) Initialize(shellPointer shell.Shell_Pointer, args *[]string, url string) error {
impl.shell = shell.NewShellProxy(shellPointer, bindings.GetAsyncWaiter())
if args != nil {
impl.args = *args
}
impl.url = url
impl.delegate.Initialize(impl)
return nil
}
// Mojo application implementation.
func (impl *ApplicationImpl) AcceptConnection(requestorURL string, resolvedURL string, services sp.ServiceProvider_Request) error {
connection := newConnection(requestorURL, services, resolvedURL)
impl.delegate.AcceptConnection(connection)
impl.addConnection(connection)
return nil
}
// Mojo application implementation.
func (impl *ApplicationImpl) RequestQuit() error {
impl.quitOnce.Do(func() {
impl.delegate.Quit()
impl.mu.Lock()
for _, c := range impl.connections {
c.Close()
}
impl.mu.Unlock()
impl.shell.Close_Proxy()
impl.runner.Close()
})
return nil
}
// Context implementaion.
func (impl *ApplicationImpl) URL() string {
return impl.url
}
// Context implementaion.
func (impl *ApplicationImpl) Args() []string {
return impl.args
}
// Context implementaion.
func (impl *ApplicationImpl) ConnectToApplication(remoteURL string) *OutgoingConnection {
servicesRequest, servicesPointer := sp.CreateMessagePipeForServiceProvider()
if err := impl.shell.ConnectToApplication(remoteURL, servicesRequest); err != nil {
log.Printf("can't connect to %v: %v", remoteURL, err)
// In case of error message pipes sent through Shell are closed and
// the connection will work as if the remote application closed
// both ServiceProvider's pipes.
}
return &OutgoingConnection{
connectionInfo{
impl.url,
remoteURL,
},
sp.NewServiceProviderProxy(servicesPointer, bindings.GetAsyncWaiter()),
}
}
func (impl *ApplicationImpl) Close() {
impl.RequestQuit()
}
// addConnection appends connections slice by a provided connection, removing
// connections that have been closed.
func (impl *ApplicationImpl) addConnection(c *Connection) {
impl.mu.Lock()
i := 0
for i < len(impl.connections) {
if impl.connections[i].isClosed {
last := len(impl.connections) - 1
impl.connections[i] = impl.connections[last]
impl.connections[last] = nil
impl.connections = impl.connections[:last]
} else {
i++
}
}
if !c.isClosed {
impl.connections = append(impl.connections, c)
}
impl.mu.Unlock()
}