Initial checkin of the new Mozart compositor.

mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/renderers.mojom.dart

Index: mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/renderers.mojom.dart
diff --git a/mojo/dart/packages/mojo/lib/mojo/shell.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/renderers.mojom.dart
similarity index 51%
copy from mojo/dart/packages/mojo/lib/mojo/shell.mojom.dart
copy to mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/renderers.mojom.dart
index 0c8d92600ee8ded3730a8109f06a1978c70c5fa9..9c8d5203d5970b40b31598c54bcc36493d26fab4 100644
--- a/mojo/dart/packages/mojo/lib/mojo/shell.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/renderers.mojom.dart
@@ -2,28 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-library shell_mojom;
+library renderers_mojom;
 
 import 'dart:async';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
-import 'package:mojo/mojo/application_connector.mojom.dart' as application_connector_mojom;
-import 'package:mojo/mojo/service_provider.mojom.dart' as service_provider_mojom;
+import 'package:mojo_services/mojo/geometry.mojom.dart' as geometry_mojom;
+import 'package:mojo_services/mojo/gfx/composition/hit_tests.mojom.dart' as hit_tests_mojom;
+import 'package:mojo_services/mojo/gfx/composition/scene_token.mojom.dart' as scene_token_mojom;
 
 
 
-class _ShellConnectToApplicationParams extends bindings.Struct {
+class _RendererSetRootSceneParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
-  String applicationUrl = null;
-  Object services = null;
-  Object exposedServices = null;
+  scene_token_mojom.SceneToken sceneToken = null;
+  int sceneVersion = 0;
+  geometry_mojom.Rect viewport = null;
 
-  _ShellConnectToApplicationParams() : super(kVersions.last.size);
+  _RendererSetRootSceneParams() : super(kVersions.last.size);
 
-  static _ShellConnectToApplicationParams deserialize(bindings.Message message) {
+  static _RendererSetRootSceneParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -32,11 +33,11 @@ class _ShellConnectToApplicationParams extends bindings.Struct {
     return result;
   }
 
-  static _ShellConnectToApplicationParams decode(bindings.Decoder decoder0) {
+  static _RendererSetRootSceneParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _ShellConnectToApplicationParams result = new _ShellConnectToApplicationParams();
+    _RendererSetRootSceneParams result = new _RendererSetRootSceneParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -58,15 +59,17 @@ class _ShellConnectToApplicationParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.applicationUrl = decoder0.decodeString(8, false);
+      var decoder1 = decoder0.decodePointer(8, false);
+      result.sceneToken = scene_token_mojom.SceneToken.decode(decoder1);
     }
     if (mainDataHeader.version >= 0) {
       
-      result.services = decoder0.decodeInterfaceRequest(16, true, service_provider_mojom.ServiceProviderStub.newFromEndpoint);
+      result.sceneVersion = decoder0.decodeUint32(16);
     }
     if (mainDataHeader.version >= 0) {
       
-      result.exposedServices = decoder0.decodeServiceInterface(20, true, service_provider_mojom.ServiceProviderProxy.newFromEndpoint);
+      var decoder1 = decoder0.decodePointer(24, false);
+      result.viewport = geometry_mojom.Rect.decode(decoder1);
     }
     return result;
   }
@@ -74,36 +77,39 @@ class _ShellConnectToApplicationParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeString(applicationUrl, 8, false);
+    encoder0.encodeStruct(sceneToken, 8, false);
     
-    encoder0.encodeInterfaceRequest(services, 16, true);
+    encoder0.encodeUint32(sceneVersion, 16);
     
-    encoder0.encodeInterface(exposedServices, 20, true);
+    encoder0.encodeStruct(viewport, 24, false);
   }
 
   String toString() {
-    return "_ShellConnectToApplicationParams("
-           "applicationUrl: $applicationUrl" ", "
-           "services: $services" ", "
-           "exposedServices: $exposedServices" ")";
+    return "_RendererSetRootSceneParams("
+           "sceneToken: $sceneToken" ", "
+           "sceneVersion: $sceneVersion" ", "
+           "viewport: $viewport" ")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    map["sceneToken"] = sceneToken;
+    map["sceneVersion"] = sceneVersion;
+    map["viewport"] = viewport;
+    return map;
   }
 }
 
 
-class _ShellCreateApplicationConnectorParams extends bindings.Struct {
+class _RendererGetHitTesterParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  Object applicationConnectorRequest = null;
+  Object hitTester = null;
 
-  _ShellCreateApplicationConnectorParams() : super(kVersions.last.size);
+  _RendererGetHitTesterParams() : super(kVersions.last.size);
 
-  static _ShellCreateApplicationConnectorParams deserialize(bindings.Message message) {
+  static _RendererGetHitTesterParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -112,11 +118,11 @@ class _ShellCreateApplicationConnectorParams extends bindings.Struct {
     return result;
   }
 
-  static _ShellCreateApplicationConnectorParams decode(bindings.Decoder decoder0) {
+  static _RendererGetHitTesterParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _ShellCreateApplicationConnectorParams result = new _ShellCreateApplicationConnectorParams();
+    _RendererGetHitTesterParams result = new _RendererGetHitTesterParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -138,7 +144,7 @@ class _ShellCreateApplicationConnectorParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.applicationConnectorRequest = decoder0.decodeInterfaceRequest(8, false, application_connector_mojom.ApplicationConnectorStub.newFromEndpoint);
+      result.hitTester = decoder0.decodeInterfaceRequest(8, false, hit_tests_mojom.HitTesterStub.newFromEndpoint);
     }
     return result;
   }
@@ -146,12 +152,12 @@ class _ShellCreateApplicationConnectorParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeInterfaceRequest(applicationConnectorRequest, 8, false);
+    encoder0.encodeInterfaceRequest(hitTester, 8, false);
   }
 
   String toString() {
-    return "_ShellCreateApplicationConnectorParams("
-           "applicationConnectorRequest: $applicationConnectorRequest" ")";
+    return "_RendererGetHitTesterParams("
+           "hitTester: $hitTester" ")";
   }
 
   Map toJson() {
@@ -160,29 +166,29 @@ class _ShellCreateApplicationConnectorParams extends bindings.Struct {
   }
 }
 
-const int _Shell_connectToApplicationName = 0;
-const int _Shell_createApplicationConnectorName = 1;
+const int _Renderer_setRootSceneName = 0;
+const int _Renderer_getHitTesterName = 1;
 
-abstract class Shell {
+abstract class Renderer {
   static const String serviceName = null;
-  void connectToApplication(String applicationUrl, Object services, Object exposedServices);
-  void createApplicationConnector(Object applicationConnectorRequest);
+  void setRootScene(scene_token_mojom.SceneToken sceneToken, int sceneVersion, geometry_mojom.Rect viewport);
+  void getHitTester(Object hitTester);
 }
 
 
-class _ShellProxyImpl extends bindings.Proxy {
-  _ShellProxyImpl.fromEndpoint(
+class _RendererProxyImpl extends bindings.Proxy {
+  _RendererProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  _ShellProxyImpl.fromHandle(core.MojoHandle handle) :
+  _RendererProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  _ShellProxyImpl.unbound() : super.unbound();
+  _RendererProxyImpl.unbound() : super.unbound();
 
-  static _ShellProxyImpl newFromEndpoint(
+  static _RendererProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For _ShellProxyImpl"));
-    return new _ShellProxyImpl.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For _RendererProxyImpl"));
+    return new _RendererProxyImpl.fromEndpoint(endpoint);
   }
 
   void handleResponse(bindings.ServiceMessage message) {
@@ -196,76 +202,76 @@ class _ShellProxyImpl extends bindings.Proxy {
 
   String toString() {
     var superString = super.toString();
-    return "_ShellProxyImpl($superString)";
+    return "_RendererProxyImpl($superString)";
   }
 }
 
 
-class _ShellProxyCalls implements Shell {
-  _ShellProxyImpl _proxyImpl;
+class _RendererProxyCalls implements Renderer {
+  _RendererProxyImpl _proxyImpl;
 
-  _ShellProxyCalls(this._proxyImpl);
-    void connectToApplication(String applicationUrl, Object services, Object exposedServices) {
+  _RendererProxyCalls(this._proxyImpl);
+    void setRootScene(scene_token_mojom.SceneToken sceneToken, int sceneVersion, geometry_mojom.Rect viewport) {
       if (!_proxyImpl.isBound) {
         _proxyImpl.proxyError("The Proxy is closed.");
         return;
       }
-      var params = new _ShellConnectToApplicationParams();
-      params.applicationUrl = applicationUrl;
-      params.services = services;
-      params.exposedServices = exposedServices;
-      _proxyImpl.sendMessage(params, _Shell_connectToApplicationName);
+      var params = new _RendererSetRootSceneParams();
+      params.sceneToken = sceneToken;
+      params.sceneVersion = sceneVersion;
+      params.viewport = viewport;
+      _proxyImpl.sendMessage(params, _Renderer_setRootSceneName);
     }
-    void createApplicationConnector(Object applicationConnectorRequest) {
+    void getHitTester(Object hitTester) {
       if (!_proxyImpl.isBound) {
         _proxyImpl.proxyError("The Proxy is closed.");
         return;
       }
-      var params = new _ShellCreateApplicationConnectorParams();
-      params.applicationConnectorRequest = applicationConnectorRequest;
-      _proxyImpl.sendMessage(params, _Shell_createApplicationConnectorName);
+      var params = new _RendererGetHitTesterParams();
+      params.hitTester = hitTester;
+      _proxyImpl.sendMessage(params, _Renderer_getHitTesterName);
     }
 }
 
 
-class ShellProxy implements bindings.ProxyBase {
+class RendererProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  Shell ptr;
+  Renderer ptr;
 
-  ShellProxy(_ShellProxyImpl proxyImpl) :
+  RendererProxy(_RendererProxyImpl proxyImpl) :
       impl = proxyImpl,
-      ptr = new _ShellProxyCalls(proxyImpl);
+      ptr = new _RendererProxyCalls(proxyImpl);
 
-  ShellProxy.fromEndpoint(
+  RendererProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) :
-      impl = new _ShellProxyImpl.fromEndpoint(endpoint) {
-    ptr = new _ShellProxyCalls(impl);
+      impl = new _RendererProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _RendererProxyCalls(impl);
   }
 
-  ShellProxy.fromHandle(core.MojoHandle handle) :
-      impl = new _ShellProxyImpl.fromHandle(handle) {
-    ptr = new _ShellProxyCalls(impl);
+  RendererProxy.fromHandle(core.MojoHandle handle) :
+      impl = new _RendererProxyImpl.fromHandle(handle) {
+    ptr = new _RendererProxyCalls(impl);
   }
 
-  ShellProxy.unbound() :
-      impl = new _ShellProxyImpl.unbound() {
-    ptr = new _ShellProxyCalls(impl);
+  RendererProxy.unbound() :
+      impl = new _RendererProxyImpl.unbound() {
+    ptr = new _RendererProxyCalls(impl);
   }
 
-  factory ShellProxy.connectToService(
+  factory RendererProxy.connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
-    ShellProxy p = new ShellProxy.unbound();
+    RendererProxy p = new RendererProxy.unbound();
     s.connectToService(url, p, serviceName);
     return p;
   }
 
-  static ShellProxy newFromEndpoint(
+  static RendererProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For ShellProxy"));
-    return new ShellProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For RendererProxy"));
+    return new RendererProxy.fromEndpoint(endpoint);
   }
 
-  String get serviceName => Shell.serviceName;
+  String get serviceName => Renderer.serviceName;
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
 
@@ -282,27 +288,27 @@ class ShellProxy implements bindings.ProxyBase {
   }
 
   String toString() {
-    return "ShellProxy($impl)";
+    return "RendererProxy($impl)";
   }
 }
 
 
-class ShellStub extends bindings.Stub {
-  Shell _impl = null;
+class RendererStub extends bindings.Stub {
+  Renderer _impl = null;
 
-  ShellStub.fromEndpoint(
+  RendererStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [this._impl])
       : super.fromEndpoint(endpoint);
 
-  ShellStub.fromHandle(core.MojoHandle handle, [this._impl])
+  RendererStub.fromHandle(core.MojoHandle handle, [this._impl])
       : super.fromHandle(handle);
 
-  ShellStub.unbound() : super.unbound();
+  RendererStub.unbound() : super.unbound();
 
-  static ShellStub newFromEndpoint(
+  static RendererStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For ShellStub"));
-    return new ShellStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For RendererStub"));
+    return new RendererStub.fromEndpoint(endpoint);
   }
 
 
@@ -315,15 +321,15 @@ class ShellStub extends bindings.Stub {
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case _Shell_connectToApplicationName:
-        var params = _ShellConnectToApplicationParams.deserialize(
+      case _Renderer_setRootSceneName:
+        var params = _RendererSetRootSceneParams.deserialize(
             message.payload);
-        _impl.connectToApplication(params.applicationUrl, params.services, params.exposedServices);
+        _impl.setRootScene(params.sceneToken, params.sceneVersion, params.viewport);
         break;
-      case _Shell_createApplicationConnectorName:
-        var params = _ShellCreateApplicationConnectorParams.deserialize(
+      case _Renderer_getHitTesterName:
+        var params = _RendererGetHitTesterParams.deserialize(
             message.payload);
-        _impl.createApplicationConnector(params.applicationConnectorRequest);
+        _impl.getHitTester(params.hitTester);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
@@ -332,15 +338,15 @@ class ShellStub extends bindings.Stub {
     return null;
   }
 
-  Shell get impl => _impl;
-  set impl(Shell d) {
+  Renderer get impl => _impl;
+  set impl(Renderer d) {
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
-    return "ShellStub($superString)";
+    return "RendererStub($superString)";
   }
 
   int get version => 0;