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/mojom_types"
 )
 
 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 {

[rudominer, 2015/10/14 05:15:41]

This does not seem right to me. I don't see why you would want to add your two
functions to this interface.

Can we discuss in person?

Let's take the case of the Echo service for example. I thought that the main use
case here was on the Vanadium server side. In that case the V23 Proxy running on
the server has not been compiled with echo.mojom.go and so it does not have the
type Echo_Request. That is it does not have an instance of this interface on
which it could call your new methods.

What I was expecting to see was that you would add an implementation of
interface ServiceDescriber from service_describer.mojom. The V23 Proxy running
on the server has been compiled with this mojom and so it has access to the type
ServiceDescriber_Request and ServiceDescriber_Pointer. It uses these to invoke
DescribeService and get a ServiceDescription.

[rudominer, 2015/10/14 06:17:55]

Sorry, I spoke to soon. I now see that in your CL description you wrote "This
allows Mojo server applications to additionally expose a ServiceDescriber
implementation that directs interface name queries to the corresponding
ServiceDescription." So it seems your idea is that each application developer
writes his own implementation of ServiceDescriber. 

I was expecting that you would be adding some infrastructure to make that
easier--for example something like add a ServiceDescriberImpl struct to this
file similar to ServiceProviderImpl below. Then provide an alternative version
of the ProvideServices() method that would, in addition to calling
ServiceProviderImpl.AddService(), also call ServiceDescriberImpl.AddService()
(or something like that.)

[alexfandrianto, 2015/10/14 06:44:50]

I actually expose Type() and Desc() for the client-side. Any application (e.g.,
a proxy) that receives a ServiceRequest can determine the types for that request
and properly handle it.

The server-side does rely on the ServiceDescriber. Much of the
ServiceDescriberImpl could probably be added to the autogenerated code. Right
now, it must be created manually and the autogenerate ServiceDescription's must
be collected and put together. I can show you what I did in-person and would
appreciate pointers on what can be autogenerated.

         // Name returns the name of requested mojo service.
         Name() string
 
+        // Type returns a type description of the interface.
+        Type() mojom_types.MojomInterface
+
+        // Descriptor returns the mapping between string identifiers and relevant UserDefinedTypes.
+        Desc() map[string]mojom_types.UserDefinedType
+
         // 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
@@ skipping 120 matching lines @@
                 messagePipe.Close()
                 return nil
         }
         factory.Create(messagePipe)
         return nil
 }
 
 func (sp *serviceProviderImpl) AddService(factory ServiceFactory) {
         sp.factories[factory.Name()] = factory
 }