Generate Mojom Types in Go

mojo/public/go/application/connection.go

 // 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"
 
         "mojo/public/go/bindings"
         "mojo/public/go/system"
 
         sp "mojo/public/interfaces/application/service_provider"
+        "mojo/public/interfaces/bindings/service_describer"
 )
 
 type connectionInfo struct {
         requestorURL  string
         connectionURL string
 }
 
 // RequestorURL returns the URL of application that established the connection.
 func (c *connectionInfo) RequestorURL() string {
         return c.requestorURL
 }
 
 // ConnectionURL returns the URL that was used by the source application to
 // establish a connection to the destination application.
 func (c *connectionInfo) ConnectionURL() string {
         return c.connectionURL
 }
 
 // ServiceRequest is an interface request for a specified mojo service.
 type ServiceRequest interface {
         // Name returns the name of requested mojo service.
         Name() string
 
+        // ServiceDescription returns a service description, which can be queried to
+        // examine the type information of the requested mojo service.

[rudominer, 2015/10/22 21:28:47]

s/of the requested mojo service/of the service associated with this
ServiceRequest./

Also can you say something about what happens if the generation of type
information is
disabled at compilation time. For example say (if this is true) "Some
implementations will
not provide type information and in that case the returned value may be nil."

[alexfandrianto, 2015/10/22 22:58:11]

Done.

+        ServiceDescription() service_describer.ServiceDescription
+
         // PassMessagePipe passes ownership of the underlying message pipe
         // handle to the newly created handle object, invalidating the
         // underlying handle object in the process.
         PassMessagePipe() system.MessagePipeHandle
 }
 
 // ServiceFactory provides implementation of a mojo service.
 type ServiceFactory interface {
         // Name returns the name of provided mojo service.
         Name() string
 
+        // ServiceDescription returns a service description, which can be queried to
+        // examine the type information of the mojo service.

[rudominer, 2015/10/22 21:28:47]

"of the mojo service associated with this ServiceFactory."

(Sorry, I know I was the one who suggested the previous wording.)

Also as above can you say something about what happens if the generation of type
information is disabled at compilation time. 

[alexfandrianto, 2015/10/22 22:58:11]

Done.

+        ServiceDescription() service_describer.ServiceDescription
+
         // Create binds an implementation of mojo service to the provided
         // message pipe and runs it.
         Create(pipe system.MessagePipeHandle)
 }
 
 // Connection represents a connection to another application. An instance of
 // this struct is passed to Delegate's AcceptConnection() function each time a
 // connection is made to this application.
 type Connection struct {
         connectionInfo
         // Request for local services. Is valid until ProvideServices is called.
         servicesRequest *sp.ServiceProvider_Request
         // Indicates that ProvideServices function was already called.
         servicesProvided   bool
         localServices      *bindings.Stub
         outgoingConnection *OutgoingConnection
         isClosed           bool
+        describer          *ServiceDescriberFactory

[rudominer, 2015/10/22 21:28:47]

Please add a comment about what happens when the generation of type information
is disabled.
Is this nil or non-functional?

[alexfandrianto, 2015/10/22 22:58:11]

The ServiceDescriber is functional, but the ServiceDescriptions obtained are
stubs. It's possible to mix and match if the implementer decided to allow a
subset of ServiceDescriptions to generate their type information though.

 }
 
 func newConnection(requestorURL string, services *sp.ServiceProvider_Request, exposedServices *sp.ServiceProvider_Pointer, resolvedURL string) *Connection {
         info := connectionInfo{
                 requestorURL,
                 resolvedURL,
         }
         var remoteServices *sp.ServiceProvider_Proxy
         if exposedServices != nil {
                 remoteServices = sp.NewServiceProviderProxy(*exposedServices, bindings.GetAsyncWaiter())
         }
         return &Connection{
                 connectionInfo:  info,
                 servicesRequest: services,
                 outgoingConnection: &OutgoingConnection{
                         info,
                         remoteServices,
                 },
         }
 }
 
 // ProvideServices starts a service provider on a separate goroutine that
 // provides given services to the remote application. Returns a pointer to
 // outgoing connection that can be used to connect to services provided by
 // remote application.
 // Panics if called more than once.
 func (c *Connection) ProvideServices(services ...ServiceFactory) *OutgoingConnection {
         if c.servicesProvided {
-                panic("ProvideServices can be called only once")
+                panic("ProvideServices or ProvideServicesWithDescriber can be called only once")
         }
         c.servicesProvided = true
         if c.servicesRequest == nil {
                 return c.outgoingConnection
         }
         if len(services) == 0 {
                 c.servicesRequest.PassMessagePipe().Close()
                 return c.outgoingConnection
         }
 
@@ skipping 11 matching lines @@
                                 if !ok || !connectionError.Closed() {
                                         log.Println(err)
                                 }
                                 break
                         }
                 }
         }()
         return c.outgoingConnection
 }
 
+// ProvideServicesWithDescriber is an alternative to ProvideServices that, in
+// addition to providing the given services, also provides type descriptions of
+// the given services. See ProvideServices for a description of what it does.
+// This method will invoke ProvideServices after appending the ServiceDescriber
+// service to |services|. See service_describer.mojom for a description of the
+// ServiceDescriber interface. Client Mojo applications can choose to connect
+// to this ServiceDescriber interface, which describes the other services listed
+// in |services|.
+// Note that the implementation of ServiceDescriber will make the optional
+// DeclarationData available on all types, and in particular, the names used in
+// .mojom files will be exposed to client applications.
+func (c *Connection) ProvideServicesWithDescriber(services ...ServiceFactory) *OutgoingConnection {
+        if c.servicesProvided {
+                panic("ProvideServices or ProvideServicesWithDescriber can be called only once")
+        }
+        mapping := make(map[string]service_describer.ServiceDescription)
+        for _, service := range services {
+                mapping[service.Name()] = service.ServiceDescription()
+        }
+        c.describer = newServiceDescriberFactory(mapping)
+        servicesWithDescriber := append(services, &service_describer.ServiceDescriber_ServiceFactory{c.describer})
+
+        return c.ProvideServices(servicesWithDescriber...)
+}
+
 // Close closes both incoming and outgoing parts of the connection.
 func (c *Connection) Close() {
         if c.servicesRequest != nil {
                 c.servicesRequest.Close()
         }
         if c.localServices != nil {
                 c.localServices.Close()
         }
+        if c.describer != nil {
+                c.describer.Close()
+        }
         if c.outgoingConnection.remoteServices != nil {
                 c.outgoingConnection.remoteServices.Close_Proxy()
         }
         c.isClosed = true
 }
 
 // OutgoingConnection represents outgoing part of connection to another
 // application. In order to close it close the |Connection| object that returned
 // this |OutgoingConnection|.
 type OutgoingConnection struct {
@@ skipping 24 matching lines @@
                 messagePipe.Close()
                 return nil
         }
         factory.Create(messagePipe)
         return nil
 }
 
 func (sp *serviceProviderImpl) AddService(factory ServiceFactory) {
         sp.factories[factory.Name()] = factory
 }