Dart: Adds Interface and InterfaceRequest interfaces.

mojo/dart/packages/mojo_services/lib/activity/activity.mojom.dart

 // Copyright 2014 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.
 
 library activity_mojom;
 import 'dart:async';
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
 import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
 
@@ skipping 679 matching lines @@
     map["primaryColor"] = primaryColor;
     return map;
   }
 }
 
 
 class _ActivityGetUserFeedbackParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  Object userFeedback = null;
+  UserFeedbackInterfaceRequest userFeedback = null;
 
   _ActivityGetUserFeedbackParams() : super(kVersions.last.size);
 
   static _ActivityGetUserFeedbackParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
@@ skipping 963 matching lines @@
 
   dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
       responseFactory(null);
 }
 
 abstract class Activity {
   static const String serviceName = "activity::Activity";
-  void getUserFeedback(Object userFeedback);
+
+  static service_describer.ServiceDescription _cachedServiceDescription;
+  static service_describer.ServiceDescription get serviceDescription {
+    if (_cachedServiceDescription == null) {
+      _cachedServiceDescription = new _ActivityServiceDescription();
+    }
+    return _cachedServiceDescription;
+  }
+
+  static ActivityProxy connectToService(
+      bindings.ServiceConnector s, String url, [String serviceName]) {
+    ActivityProxy p = new ActivityProxy.unbound();
+    String name = serviceName ?? Activity.serviceName;
+    if ((name == null) || name.isEmpty) {
+      throw new core.MojoApiError(
+          "If an interface has no ServiceName, then one must be provided.");
+    }
+    s.connectToService(url, p, name);
+    return p;
+  }
+  void getUserFeedback(UserFeedbackInterfaceRequest userFeedback);
   void startActivity(Intent intent);
   void finishCurrentActivity();
   void setTaskDescription(TaskDescription description);
   void setSystemUiVisibility(SystemUiVisibility visibility);
   void setRequestedOrientation(ScreenOrientation orientation);
 }
 
+abstract class ActivityInterface
+    implements bindings.MojoInterface<Activity>,
+               Activity {
+  factory ActivityInterface([Activity impl]) =>
+      new ActivityStub.unbound(impl);
+  factory ActivityInterface.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint,
+      [Activity impl]) =>
+      new ActivityStub.fromEndpoint(endpoint, impl);
+}
+
+abstract class ActivityInterfaceRequest
+    implements bindings.MojoInterface<Activity>,
+               Activity {
+  factory ActivityInterfaceRequest() =>
+      new ActivityProxy.unbound();
+}
+
 class _ActivityProxyControl
     extends bindings.ProxyMessageHandler
-    implements bindings.ProxyControl {
+    implements bindings.ProxyControl<Activity> {
   _ActivityProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _ActivityProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _ActivityProxyControl.unbound() : super.unbound();
 
-  service_describer.ServiceDescription get serviceDescription =>
-      new _ActivityServiceDescription();
-
   String get serviceName => Activity.serviceName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
+  Activity get impl => null;
+  set impl(Activity _) {
+    throw new core.MojoApiError("The impl of a Proxy cannot be set.");
+  }
+
   @override
   String toString() {
     var superString = super.toString();
     return "_ActivityProxyControl($superString)";
   }
 }
 
 class ActivityProxy
-    extends bindings.Proxy
-    implements Activity {
+    extends bindings.Proxy<Activity>
+    implements Activity,
+               ActivityInterface,
+               ActivityInterfaceRequest {
   ActivityProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _ActivityProxyControl.fromEndpoint(endpoint));
 
   ActivityProxy.fromHandle(core.MojoHandle handle)
       : super(new _ActivityProxyControl.fromHandle(handle));
 
   ActivityProxy.unbound()
       : super(new _ActivityProxyControl.unbound());
 
   static ActivityProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For ActivityProxy"));
     return new ActivityProxy.fromEndpoint(endpoint);
   }
 
-  factory ActivityProxy.connectToService(
-      bindings.ServiceConnector s, String url, [String serviceName]) {
-    ActivityProxy p = new ActivityProxy.unbound();
-    s.connectToService(url, p, serviceName);
-    return p;
-  }
 
-
-  void getUserFeedback(Object userFeedback) {
+  void getUserFeedback(UserFeedbackInterfaceRequest userFeedback) {
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _ActivityGetUserFeedbackParams();
     params.userFeedback = userFeedback;
     ctrl.sendMessage(params,
         _activityMethodGetUserFeedbackName);
   }
   void startActivity(Intent intent) {
@@ skipping 59 matching lines @@
   }
 
   _ActivityStubControl.fromHandle(
       core.MojoHandle handle, [Activity impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _ActivityStubControl.unbound([this._impl]) : super.unbound();
 
+  String get serviceName => Activity.serviceName;
+
 
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           0,
                                                           message);
     }
     if (_impl == null) {
       throw new core.MojoApiError("$this has no implementation set");
@@ skipping 53 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_ActivityStubControl($superString)";
   }
 
   int get version => 0;
-
-  static service_describer.ServiceDescription _cachedServiceDescription;
-  static service_describer.ServiceDescription get serviceDescription {
-    if (_cachedServiceDescription == null) {
-      _cachedServiceDescription = new _ActivityServiceDescription();
-    }
-    return _cachedServiceDescription;
-  }
 }
 
 class ActivityStub
     extends bindings.Stub<Activity>
-    implements Activity {
+    implements Activity,
+               ActivityInterface,
+               ActivityInterfaceRequest {
+  ActivityStub.unbound([Activity impl])
+      : super(new _ActivityStubControl.unbound(impl));
+
   ActivityStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [Activity impl])
       : super(new _ActivityStubControl.fromEndpoint(endpoint, impl));
 
   ActivityStub.fromHandle(
       core.MojoHandle handle, [Activity impl])
       : super(new _ActivityStubControl.fromHandle(handle, impl));
 
-  ActivityStub.unbound([Activity impl])
-      : super(new _ActivityStubControl.unbound(impl));
-
   static ActivityStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For ActivityStub"));
     return new ActivityStub.fromEndpoint(endpoint);
   }
 
-  static service_describer.ServiceDescription get serviceDescription =>
-      _ActivityStubControl.serviceDescription;
 
-
-  void getUserFeedback(Object userFeedback) {
+  void getUserFeedback(UserFeedbackInterfaceRequest userFeedback) {
     return impl.getUserFeedback(userFeedback);
   }
   void startActivity(Intent intent) {
     return impl.startActivity(intent);
   }
   void finishCurrentActivity() {
     return impl.finishCurrentActivity();
   }
   void setTaskDescription(TaskDescription description) {
     return impl.setTaskDescription(description);
@@ skipping 16 matching lines @@
 
   dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
       responseFactory(null);
 }
 
 abstract class PathService {
   static const String serviceName = "activity::PathService";
+
+  static service_describer.ServiceDescription _cachedServiceDescription;
+  static service_describer.ServiceDescription get serviceDescription {
+    if (_cachedServiceDescription == null) {
+      _cachedServiceDescription = new _PathServiceServiceDescription();
+    }
+    return _cachedServiceDescription;
+  }
+
+  static PathServiceProxy connectToService(
+      bindings.ServiceConnector s, String url, [String serviceName]) {
+    PathServiceProxy p = new PathServiceProxy.unbound();
+    String name = serviceName ?? PathService.serviceName;
+    if ((name == null) || name.isEmpty) {
+      throw new core.MojoApiError(
+          "If an interface has no ServiceName, then one must be provided.");
+    }
+    s.connectToService(url, p, name);
+    return p;
+  }
   dynamic getAppDataDir([Function responseFactory = null]);
   dynamic getFilesDir([Function responseFactory = null]);
   dynamic getCacheDir([Function responseFactory = null]);
 }
 
+abstract class PathServiceInterface
+    implements bindings.MojoInterface<PathService>,
+               PathService {
+  factory PathServiceInterface([PathService impl]) =>
+      new PathServiceStub.unbound(impl);
+  factory PathServiceInterface.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint,
+      [PathService impl]) =>
+      new PathServiceStub.fromEndpoint(endpoint, impl);
+}
+
+abstract class PathServiceInterfaceRequest
+    implements bindings.MojoInterface<PathService>,
+               PathService {
+  factory PathServiceInterfaceRequest() =>
+      new PathServiceProxy.unbound();
+}
+
 class _PathServiceProxyControl
     extends bindings.ProxyMessageHandler
-    implements bindings.ProxyControl {
+    implements bindings.ProxyControl<PathService> {
   _PathServiceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _PathServiceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _PathServiceProxyControl.unbound() : super.unbound();
 
-  service_describer.ServiceDescription get serviceDescription =>
-      new _PathServiceServiceDescription();
-
   String get serviceName => PathService.serviceName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _pathServiceMethodGetAppDataDirName:
         var r = PathServiceGetAppDataDirResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
@@ skipping 51 matching lines @@
         }
         c.complete(r);
         break;
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
+  PathService get impl => null;
+  set impl(PathService _) {
+    throw new core.MojoApiError("The impl of a Proxy cannot be set.");
+  }
+
   @override
   String toString() {
     var superString = super.toString();
     return "_PathServiceProxyControl($superString)";
   }
 }
 
 class PathServiceProxy
-    extends bindings.Proxy
-    implements PathService {
+    extends bindings.Proxy<PathService>
+    implements PathService,
+               PathServiceInterface,
+               PathServiceInterfaceRequest {
   PathServiceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _PathServiceProxyControl.fromEndpoint(endpoint));
 
   PathServiceProxy.fromHandle(core.MojoHandle handle)
       : super(new _PathServiceProxyControl.fromHandle(handle));
 
   PathServiceProxy.unbound()
       : super(new _PathServiceProxyControl.unbound());
 
   static PathServiceProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For PathServiceProxy"));
     return new PathServiceProxy.fromEndpoint(endpoint);
   }
 
-  factory PathServiceProxy.connectToService(
-      bindings.ServiceConnector s, String url, [String serviceName]) {
-    PathServiceProxy p = new PathServiceProxy.unbound();
-    s.connectToService(url, p, serviceName);
-    return p;
-  }
-
 
   dynamic getAppDataDir([Function responseFactory = null]) {
     var params = new _PathServiceGetAppDataDirParams();
     return ctrl.sendMessageWithRequestId(
         params,
         _pathServiceMethodGetAppDataDirName,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse);
   }
   dynamic getFilesDir([Function responseFactory = null]) {
@@ skipping 26 matching lines @@
   }
 
   _PathServiceStubControl.fromHandle(
       core.MojoHandle handle, [PathService impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _PathServiceStubControl.unbound([this._impl]) : super.unbound();
 
+  String get serviceName => PathService.serviceName;
+
 
   PathServiceGetAppDataDirResponseParams _pathServiceGetAppDataDirResponseParamsFactory(String path) {
     var result = new PathServiceGetAppDataDirResponseParams();
     result.path = path;
     return result;
   }
   PathServiceGetFilesDirResponseParams _pathServiceGetFilesDirResponseParamsFactory(String path) {
     var result = new PathServiceGetFilesDirResponseParams();
     result.path = path;
     return result;
@@ skipping 100 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_PathServiceStubControl($superString)";
   }
 
   int get version => 0;
-
-  static service_describer.ServiceDescription _cachedServiceDescription;
-  static service_describer.ServiceDescription get serviceDescription {
-    if (_cachedServiceDescription == null) {
-      _cachedServiceDescription = new _PathServiceServiceDescription();
-    }
-    return _cachedServiceDescription;
-  }
 }
 
 class PathServiceStub
     extends bindings.Stub<PathService>
-    implements PathService {
+    implements PathService,
+               PathServiceInterface,
+               PathServiceInterfaceRequest {
+  PathServiceStub.unbound([PathService impl])
+      : super(new _PathServiceStubControl.unbound(impl));
+
   PathServiceStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [PathService impl])
       : super(new _PathServiceStubControl.fromEndpoint(endpoint, impl));
 
   PathServiceStub.fromHandle(
       core.MojoHandle handle, [PathService impl])
       : super(new _PathServiceStubControl.fromHandle(handle, impl));
 
-  PathServiceStub.unbound([PathService impl])
-      : super(new _PathServiceStubControl.unbound(impl));
-
   static PathServiceStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For PathServiceStub"));
     return new PathServiceStub.fromEndpoint(endpoint);
   }
 
-  static service_describer.ServiceDescription get serviceDescription =>
-      _PathServiceStubControl.serviceDescription;
-
 
   dynamic getAppDataDir([Function responseFactory = null]) {
     return impl.getAppDataDir(responseFactory);
   }
   dynamic getFilesDir([Function responseFactory = null]) {
     return impl.getFilesDir(responseFactory);
   }
   dynamic getCacheDir([Function responseFactory = null]) {
     return impl.getCacheDir(responseFactory);
   }
 }
 
 const int _userFeedbackMethodPerformHapticFeedbackName = 0;
 const int _userFeedbackMethodPerformAuralFeedbackName = 1;
 
 class _UserFeedbackServiceDescription implements service_describer.ServiceDescription {
   dynamic getTopLevelInterface([Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
       responseFactory(null);
 }
 
 abstract class UserFeedback {
   static const String serviceName = null;
+
+  static service_describer.ServiceDescription _cachedServiceDescription;
+  static service_describer.ServiceDescription get serviceDescription {
+    if (_cachedServiceDescription == null) {
+      _cachedServiceDescription = new _UserFeedbackServiceDescription();
+    }
+    return _cachedServiceDescription;
+  }
+
+  static UserFeedbackProxy connectToService(
+      bindings.ServiceConnector s, String url, [String serviceName]) {
+    UserFeedbackProxy p = new UserFeedbackProxy.unbound();
+    String name = serviceName ?? UserFeedback.serviceName;
+    if ((name == null) || name.isEmpty) {
+      throw new core.MojoApiError(
+          "If an interface has no ServiceName, then one must be provided.");
+    }
+    s.connectToService(url, p, name);
+    return p;
+  }
   void performHapticFeedback(HapticFeedbackType type);
   void performAuralFeedback(AuralFeedbackType type);
 }
 
+abstract class UserFeedbackInterface
+    implements bindings.MojoInterface<UserFeedback>,
+               UserFeedback {
+  factory UserFeedbackInterface([UserFeedback impl]) =>
+      new UserFeedbackStub.unbound(impl);
+  factory UserFeedbackInterface.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint,
+      [UserFeedback impl]) =>
+      new UserFeedbackStub.fromEndpoint(endpoint, impl);
+}
+
+abstract class UserFeedbackInterfaceRequest
+    implements bindings.MojoInterface<UserFeedback>,
+               UserFeedback {
+  factory UserFeedbackInterfaceRequest() =>
+      new UserFeedbackProxy.unbound();
+}
+
 class _UserFeedbackProxyControl
     extends bindings.ProxyMessageHandler
-    implements bindings.ProxyControl {
+    implements bindings.ProxyControl<UserFeedback> {
   _UserFeedbackProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _UserFeedbackProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _UserFeedbackProxyControl.unbound() : super.unbound();
 
-  service_describer.ServiceDescription get serviceDescription =>
-      new _UserFeedbackServiceDescription();
-
   String get serviceName => UserFeedback.serviceName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
+  UserFeedback get impl => null;
+  set impl(UserFeedback _) {
+    throw new core.MojoApiError("The impl of a Proxy cannot be set.");
+  }
+
   @override
   String toString() {
     var superString = super.toString();
     return "_UserFeedbackProxyControl($superString)";
   }
 }
 
 class UserFeedbackProxy
-    extends bindings.Proxy
-    implements UserFeedback {
+    extends bindings.Proxy<UserFeedback>
+    implements UserFeedback,
+               UserFeedbackInterface,
+               UserFeedbackInterfaceRequest {
   UserFeedbackProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _UserFeedbackProxyControl.fromEndpoint(endpoint));
 
   UserFeedbackProxy.fromHandle(core.MojoHandle handle)
       : super(new _UserFeedbackProxyControl.fromHandle(handle));
 
   UserFeedbackProxy.unbound()
       : super(new _UserFeedbackProxyControl.unbound());
 
   static UserFeedbackProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For UserFeedbackProxy"));
     return new UserFeedbackProxy.fromEndpoint(endpoint);
   }
 
-  factory UserFeedbackProxy.connectToService(
-      bindings.ServiceConnector s, String url, [String serviceName]) {
-    UserFeedbackProxy p = new UserFeedbackProxy.unbound();
-    s.connectToService(url, p, serviceName);
-    return p;
-  }
-
 
   void performHapticFeedback(HapticFeedbackType type) {
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _UserFeedbackPerformHapticFeedbackParams();
     params.type = type;
     ctrl.sendMessage(params,
         _userFeedbackMethodPerformHapticFeedbackName);
@@ skipping 22 matching lines @@
   }
 
   _UserFeedbackStubControl.fromHandle(
       core.MojoHandle handle, [UserFeedback impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _UserFeedbackStubControl.unbound([this._impl]) : super.unbound();
 
+  String get serviceName => UserFeedback.serviceName;
+
 
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           0,
                                                           message);
     }
     if (_impl == null) {
       throw new core.MojoApiError("$this has no implementation set");
@@ skipping 35 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_UserFeedbackStubControl($superString)";
   }
 
   int get version => 0;
-
-  static service_describer.ServiceDescription _cachedServiceDescription;
-  static service_describer.ServiceDescription get serviceDescription {
-    if (_cachedServiceDescription == null) {
-      _cachedServiceDescription = new _UserFeedbackServiceDescription();
-    }
-    return _cachedServiceDescription;
-  }
 }
 
 class UserFeedbackStub
     extends bindings.Stub<UserFeedback>
-    implements UserFeedback {
+    implements UserFeedback,
+               UserFeedbackInterface,
+               UserFeedbackInterfaceRequest {
+  UserFeedbackStub.unbound([UserFeedback impl])
+      : super(new _UserFeedbackStubControl.unbound(impl));
+
   UserFeedbackStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [UserFeedback impl])
       : super(new _UserFeedbackStubControl.fromEndpoint(endpoint, impl));
 
   UserFeedbackStub.fromHandle(
       core.MojoHandle handle, [UserFeedback impl])
       : super(new _UserFeedbackStubControl.fromHandle(handle, impl));
 
-  UserFeedbackStub.unbound([UserFeedback impl])
-      : super(new _UserFeedbackStubControl.unbound(impl));
-
   static UserFeedbackStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For UserFeedbackStub"));
     return new UserFeedbackStub.fromEndpoint(endpoint);
   }
 
-  static service_describer.ServiceDescription get serviceDescription =>
-      _UserFeedbackStubControl.serviceDescription;
-
 
   void performHapticFeedback(HapticFeedbackType type) {
     return impl.performHapticFeedback(type);
   }
   void performAuralFeedback(AuralFeedbackType type) {
     return impl.performAuralFeedback(type);
   }
 }