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.
+        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 provided mojo service.

[rudominer, 2015/10/20 21:14:06]

s/the provided mojo service/the mojo service/.

The problem with "the provided mojo services" is that it sounds like the caller
of ServiceDescription() is providing it.

[alexfandrianto, 2015/10/20 23:08:03]

Done. My original reason for having it was to echo the comment for Name(), which
also says 'provided mojo service'.

+        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
 }
 
 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())
@@ skipping 40 matching lines @@
                                 if !ok || !connectionError.Closed() {
                                         log.Println(err)
                                 }
                                 break
                         }
                 }
         }()
         return c.outgoingConnection
 }
 
+// ProvideServicesWithDescriber calls ProvideServices with a ServiceDescriber.
+// The ServiceDescriber will have knowledge of all of the services passed in.

[rudominer, 2015/10/20 21:14:06]

This method is part of the API consumed by an application developer and so this
comment should be written in a way that will help that person. I think this
comment should say something like the following:

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 one additional service to
|services| namely the ServiceDescriber service. Client Mojo applications may
request the ServiceDescriber service using the name "_ServiceDescriber". See
service_describer.mojom for a description of the ServiceDescriber interface. The
implementation of ServiceDescriber given will be able to describe the services
listed in |services|.
Note that the implementation of ServiceDescriber will make the optional
DeclarationData available on all types and in particular names used in .mojom
files will be exposed to client applications.

[alexfandrianto, 2015/10/20 23:08:03]

I improved the comment with most of your suggestions.

One thing that stuck out to me is the interface name. When I was implementing my
proxy, I was able to connect normally without explicitly mentioning the name:

r, p := service_describer.CreateMessagePipeForServiceDescriber()
fs.appctx.ConnectToApplication(mojourl).ConnectToService(&r)
sDescriber := service_describer.NewServiceDescriberProxy(p,
bindings.GetAsyncWaiter())
defer sDescriber.Close_Proxy()

+func (c *Connection) ProvideServicesWithDescriber(services ...ServiceFactory) *OutgoingConnection {
+        if c.servicesProvided {
+                panic("ProvideServices can be called only once")

[rudominer, 2015/10/20 21:14:06]

"ProvideServices or ProvideServicesWithDescriber can be called only once"

[alexfandrianto, 2015/10/20 23:08:03]

That's true. Done.

+        }
+        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
 }