Dart: Wait to handle events on a Stub until it makes sense to do it.

mojo/public/tools/bindings/generators/dart_templates/interface_definition.tmpl

 {%- for method in interface.methods %}
 const int _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name = {{method.ordinal}};
 {%- endfor %}
 
 {#--- Interface Enums #}
 {%- from "enum_definition.tmpl" import enum_def -%}
 {%- for enum in interface.enums %}
   {{ enum_def(enum, typepkg, package) }}
 {%-  endfor %}
 
@@ skipping 213 matching lines @@
     impl.requireVersion(requiredVersion);
   }
 
   String toString() {
     return "{{interface|name}}Proxy($impl)";
   }
 }
 
 
 class {{interface|name}}Stub extends bindings.Stub {
-  {{interface|name}} _impl = null;
+  {{interface|name}} _impl;
 
   {{interface|name}}Stub.fromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint, [this._impl])
-      : super.fromEndpoint(endpoint);
+      core.MojoMessagePipeEndpoint endpoint, [{{interface|name}} impl])
+      : super.fromEndpoint(endpoint, autoBegin: impl != null) {
+    _impl = impl;
+  }
 
-  {{interface|name}}Stub.fromHandle(core.MojoHandle handle, [this._impl])
-      : super.fromHandle(handle);
+  {{interface|name}}Stub.fromHandle(
+      core.MojoHandle handle, [{{interface|name}} impl])
+      : super.fromHandle(handle, autoBegin: impl != null) {
+    _impl = impl;
+  }
 
   {{interface|name}}Stub.unbound() : super.unbound();
 
   static {{interface|name}}Stub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For {{interface|name}}Stub"));
     return new {{interface|name}}Stub.fromEndpoint(endpoint);
   }
 
 {% for method in interface.methods %}
@@ skipping 12 matching lines @@
   }
 {%- endif %}
 {%- endfor %}
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           {{interface.version}},
                                                           message);
     }
-    assert(_impl != null);
+    if (_impl == null) {
+      throw new core.MojoApiError("$this has no implementation set");
+    }
     switch (message.header.type) {
 {%- for method in interface.methods %}
 {%- set request_struct = method.param_struct %}
       case _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name:
 {%- if method.parameters %}
         var params = {{request_struct|name}}.deserialize(
             message.payload);
 {%- endif %}
 {%- if method.response_parameters == None %}
         _impl.{{method|name}}(
@@ skipping 30 matching lines @@
 {%- endfor %}
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
     return null;
   }
 
   {{interface|name}} get impl => _impl;
   set impl({{interface|name}} d) {
-    assert(_impl == null);
+    if (d == null) {
+      throw new core.MojoApiError("$this: Cannot set a null implementation");
+    }
+    if (isBound && (_impl == null)) {
+      beginHandlingEvents();
+    }
     _impl = d;
   }
 
+  @override
+  void bind(core.MojoMessagePipeEndpoint endpoint) {
+    super.bind(endpoint);
+    if (!isOpen && (_impl != null)) {
+      beginHandlingEvents();
+    }
+  }
+
   String toString() {
     var superString = super.toString();
     return "{{interface|name}}Stub($superString)";
   }
 
   int get version => {{interface.version}};
 
   static {{descpkg}}ServiceDescription _cachedServiceDescription;
   static {{descpkg}}ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _{{interface|name}}ServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }