Update mojo sdk to rev 04a510fb37db10642e156957f9b2c11c2f6442ac

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
 {%- macro alloc_params(parameters) %}
 {%-   for param in parameters %}
 {%-     if param.kind|is_object_kind  %}
 {{param.kind|cpp_result_type}} p{{loop.index}};
 Deserialize_(params->{{param.name}}.ptr, &p{{loop.index}});
@@ skipping 212 matching lines @@
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters == None %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       params->DecodePointersAndHandles(message->mutable_handles());
       {{alloc_params(method.parameters)|indent(6)}}
+      // A null |sink_| typically means there is a missing call to
+      // InterfacePtr::set_client().
+      assert(sink_);
       sink_->{{method.name}}({{pass_params(method.parameters)}});
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 bool {{class_name}}Stub::AcceptWithResponder(
     mojo::Message* message, mojo::MessageReceiver* responder) {
 {%- if interface.methods %}
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters != None %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       params->DecodePointersAndHandles(message->mutable_handles());
       {{interface_macros.declare_callback(method)}}::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(), responder);
       {{interface_macros.declare_callback(method)}} callback(runnable);
       {{alloc_params(method.parameters)|indent(6)}}
+      // A null |sink_| typically means there is a missing call to
+      // InterfacePtr::set_client().
+      assert(sink_);
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
@@ skipping 26 matching lines @@
       if (!internal::{{class_name}}_{{method.name}}_Params_Data::Validate(
               message->payload(), &bounds_checker)) {
         return false;
       }
       break;
     }
 {%-   endfor %}
   }
 {%- endif %}
 
+  // A null |sink_| typically means there is a missing call to
+  // InterfacePtr::set_client().
+  assert(sink_);
   return sink_->Accept(message);
 }
 
 {#--- Response validator definitions #}
 {% if interface|has_callbacks %}
 {{class_name}}ResponseValidator::{{class_name}}ResponseValidator(
     mojo::MessageReceiver* sink) : MessageFilter(sink) {
 }
 
 bool {{class_name}}ResponseValidator::Accept(mojo::Message* message) {
 {%- if interface.methods %}
   switch (message->header()->name) {
 {%-   for method in interface.methods if method.response_parameters != None %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
       if (!message->has_flag(mojo::internal::kMessageIsResponse))
         break;
       mojo::internal::BoundsChecker bounds_checker(
           message->payload(), message->payload_num_bytes(),
           message->handles()->size());
       if (!internal::{{class_name}}_{{method.name}}_ResponseParams_Data::Validate(
               message->payload(), &bounds_checker)) {
         return false;
       }
       break;
     }
 {%-   endfor %}
   }
 {%- endif %}
 
+  // A null |sink_| typically means there is a missing call to
+  // InterfacePtr::set_client().
+  assert(sink_);
   return sink_->Accept(message);
 }
 {%- endif -%}