Move generated Mojo C++ error reporting code out of line

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, params, message, serialization_context,
                        description) %}
   ({{serialization_context}})->handles.Swap(({{message}})->mutable_handles());
   bool success = true;
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_wrapper_type}} p_{{param.field.name}}{};
 {%-   endfor %}
   {{struct.name}}DataView input_data_view({{params}},
                                           {{serialization_context}});
   {{struct_macros.deserialize(struct, "input_data_view", "p_%s", "success")}}
   if (!success) {
-    mojo::internal::ValidationContext validation_context(
-        {{message}}->data(), {{message}}->data_num_bytes(),
-        {{message}}->handles()->size(), {{message}},
+    ReportValidationErrorForMessage(
+        {{message}},
+        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
         "{{description}} deserializer");
-    ReportValidationError(
-        &validation_context,
-        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED);
     return false;
   }
 {%- endmacro %}
 
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
 std::move(p_{{param.name}})
 {%-     if not loop.last %}, {% endif %}
 {%-   endfor %}
 {%- endmacro %}
@@ skipping 57 matching lines @@
   {{param.kind|cpp_wrapper_type}}* out_{{param.name}}_;
 {%-       endfor -%}
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_HandleSyncResponse);
 };
 bool {{class_name}}_{{method.name}}_HandleSyncResponse::Accept(
     mojo::Message* message) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
+{%-       set desc = class_name~"::"~method.name~" response" %}

[yzshen1, 2016/07/31 07:16:32]

:D good catch.

One thing may be worth considering is to measure how much space such diagnostic
string  literals take and see whether we need to make improvements there.

[tibell, 2016/07/31 23:50:29]

Agreed. It's on my list.

   {{alloc_params(method.response_param_struct, "params", "message",
-                 "&serialization_context_",
-                 "{{class_name}}::{{method.name}} response")}}
+                 "&serialization_context_", desc)}}
 
 {%-       for param in method.response_parameters %}
   *out_{{param.name}}_ = std::move(p_{{param.name}});
 {%-       endfor %}
   *result_ = true;
   return true;
 }
 {%-     endif %}
 
 class {{class_name}}_{{method.name}}_ForwardToCallback
@@ skipping 10 matching lines @@
   {{class_name}}::{{method.name}}Callback callback_;
   mojo::internal::SerializationContext serialization_context_;
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback);
 };
 bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
     mojo::Message* message) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
+{%-     set desc = class_name~"::"~method.name~" response" %}
   {{alloc_params(method.response_param_struct, "params", "message",
-                 "&serialization_context_",
-                 "{{class_name}}_{{method.name}} response")}}
+                 "&serialization_context_", desc)}}
   if (!callback_.is_null())
     callback_.Run({{pass_params(method.response_parameters)}});
   return true;
 }
 {%-   endif %}
 {%- endfor %}
 
 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
     : ControlMessageProxy(receiver) {
 }
@@ skipping 61 matching lines @@
 {%- endfor %}
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method.response_param_struct %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
-class {{class_name}}_{{method.name}}_ProxyToResponder
-    : public base::RefCountedThreadSafe<
-          {{class_name}}_{{method.name}}_ProxyToResponder> {
+class {{class_name}}_{{method.name}}_ProxyToResponder {
  public:
   static {{class_name}}::{{method.name}}Callback CreateCallback(
       uint64_t request_id,
       bool is_sync,
       mojo::MessageReceiverWithStatus* responder,
       scoped_refptr<mojo::AssociatedGroupController>
           group_controller) {
-    scoped_refptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy
-        = new {{class_name}}_{{method.name}}_ProxyToResponder(
-            request_id, is_sync, responder, group_controller);
+    std::unique_ptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy(
+        new {{class_name}}_{{method.name}}_ProxyToResponder(
+            request_id, is_sync, responder, group_controller));
     return base::Bind(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
-                      proxy);
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<
-      {{class_name}}_{{method.name}}_ProxyToResponder>;
-
-  {{class_name}}_{{method.name}}_ProxyToResponder(
-      uint64_t request_id,
-      bool is_sync,
-      mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::AssociatedGroupController> group_controller)
-      : request_id_(request_id),
-        is_sync_(is_sync),
-        responder_(responder),
-        serialization_context_(std::move(group_controller)) {
+                      base::Passed(&proxy));
   }
 
   ~{{class_name}}_{{method.name}}_ProxyToResponder() {
 #if DCHECK_IS_ON()
     if (responder_) {
       // Is the Mojo application destroying the callback without running it
       // and without first closing the pipe?
       responder_->DCheckInvalid("The callback passed to "
           "{{class_name}}::{{method.name}}() was never run.");
     }
 #endif
     // If the Callback was dropped then deleting the responder will close
     // the pipe so the calling application knows to stop waiting for a reply.
     delete responder_;
   }
 
+ private:
+  {{class_name}}_{{method.name}}_ProxyToResponder(
+      uint64_t request_id,
+      bool is_sync,
+      mojo::MessageReceiverWithStatus* responder,
+      scoped_refptr<mojo::AssociatedGroupController> group_controller)
+      : request_id_(request_id),
+        is_sync_(is_sync),
+        responder_(responder),
+        serialization_context_(std::move(group_controller)) {
+  }
+
   void Run(
       {{interface_macros.declare_responder_params(
           "in_", method.response_parameters, for_blink,
           use_new_wrapper_types)}});
 
   uint64_t request_id_;
   bool is_sync_;
   mojo::MessageReceiverWithStatus* responder_;
   // TODO(yzshen): maybe I should use a ref to the original one?
   mojo::internal::SerializationContext serialization_context_;
@@ skipping 37 matching lines @@
     return control_message_handler_.Accept(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 %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
+{%-       set desc = class_name~"::"~method.name %}
       {{alloc_params(method.param_struct, "params", "message",
-          "&serialization_context_", "{{class_name}}::{{method.name}}")
+          "&serialization_context_", desc)
               |indent(4)}}

[yzshen1, 2016/07/31 07:16:32]

nit: now this line could be merged with the one above.

[tibell, 2016/07/31 23:50:29]

Done.

       // A null |sink_| means no implementation was bound.
       assert(sink_);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       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::MessageReceiverWithStatus* responder) {
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
     return control_message_handler_.AcceptWithResponder(message, 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());
 
+{%-       set desc = class_name~"::"~method.name %}
       {{alloc_params(method.param_struct, "params", "message",
-          "&serialization_context_", "{{class_name}}::{{method.name}}")|
+          "&serialization_context_", desc)|
               indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
               message->has_flag(mojo::Message::kFlagIsSync),
               responder,
               serialization_context_.group_controller);
       // A null |sink_| means no implementation was bound.
       assert(sink_);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
@@ skipping 98 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}