CPP bindings: DCHECK when a Callback is destructed without being invoked

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- import "struct_macros.tmpl" as struct_macros %}
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
 {%- macro alloc_params(struct) %}
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_result_type}} p_{{param.field.name}}{};
 {%-   endfor %}
@@ skipping 98 matching lines @@
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method|response_struct_from_method %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder
     : public {{class_name}}::{{method.name}}Callback::Runnable {
  public:
   virtual ~{{class_name}}_{{method.name}}_ProxyToResponder() {
     delete responder_;
-    // TODO(rudominer) DCHECK if |was_run_| is false and we don't have evidence
-    // that we are in a legitamte shutdown case such as the Connector detected
-    // an error or Close() was invoked.
+    {{class_name}}Stub* stub = associated_stub_.value();
+    if (stub && !stub->connection_error_occurred() && !stub->closed()) {
+      MOJO_DCHECK(was_run_)  << "The callback passed to "
+          "{{class_name}}::{{method.name}}({%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback) "
+          "was never run.";
+    }
   }
 
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
-      mojo::MessageReceiver* responder)
+      mojo::MessageReceiver* responder,
+      const ::mojo::internal::SharedData<{{class_name}}Stub*>& stub)
       : request_id_(request_id),
         responder_(responder),
+        associated_stub_(stub),
         was_run_(false) {
   }
 
   virtual void Run({{interface_macros.declare_params("in_", method.response_parameters)}}) const override;
 
  private:
   uint64_t request_id_;
   mutable mojo::MessageReceiver* responder_;
+  ::mojo::internal::SharedData<{{class_name}}Stub*> associated_stub_;
   mutable bool was_run_;
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_params("in_", method.response_parameters)}}) const {
   was_run_ = true;
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s")}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, size, request_id_);
   {{build_message(response_params_struct, params_description)}}
   bool ok = responder_->Accept(&message);
   MOJO_ALLOW_UNUSED_LOCAL(ok);
   // TODO(darin): !ok returned here indicates a malformed message, and that may
   // be good reason to close the connection. However, we don't have a way to do
   // that from here. We should add a way.
   delete responder_;
   responder_ = nullptr;
 }
 {%-   endif -%}
 {%- endfor %}
 
 {{class_name}}Stub::{{class_name}}Stub()
-    : sink_(nullptr) {
+    : sink_(nullptr), weak_self_(this), connection_error_occurred_(false), 
+    closed_(false) {
+}
+
+{{class_name}}Stub::~{{interface.name}}Stub() {
+  weak_self_.set_value(nullptr);
 }
 
 {#--- Stub definition #}
 
 bool {{class_name}}Stub::Accept(mojo::Message* message) {
 {%- 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 %}
@@ skipping 24 matching lines @@
 {%-   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());
       {{class_name}}::{{method.name}}Callback::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
-              message->request_id(), responder);
+              message->request_id(), responder, weak_self_);
       {{class_name}}::{{method.name}}Callback callback(runnable);
       {{alloc_params(method|struct_from_method)|indent(4)}}
       // A null |sink_| means no implementation was bound.
       assert(sink_);
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
 {%-     endif %}
@@ skipping 64 matching lines @@
       break;
     }
 {%-   endfor %}
   }
 {%- endif %}
 
   assert(sink_);
   return sink_->Accept(message);
 }
 {%- endif -%}