Mojo: Get rid of some EOL whitespace in C++ .tmpl files.

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" %}
 
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
 {%-     if param.kind|is_object_kind -%}
 mojo::internal::Wrap(params->{{param.name}}())
 {%-     elif param.kind|is_handle_kind -%}
 mojo::MakePassable(params->{{param.name}}()).Pass()
@@ skipping 49 matching lines @@
       : callback_(callback) {
   }
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE;
   virtual bool AcceptWithResponder(
       mojo::Message* message,
       mojo::MessageReceiver* responder) MOJO_OVERRIDE {
     assert(false);
     return false;
   }
  private:
-  {{interface_macros.declare_callback(method)}} callback_; 
+  {{interface_macros.declare_callback(method)}} callback_;
   MOJO_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());
 
   if (!params->DecodePointersAndHandles(message))
     return false;
@@ skipping 61 matching lines @@
 
   virtual void Run({{interface_macros.declare_params(method.response_parameters)}}) const;
 
  private:
   uint64_t request_id_;
   mutable mojo::MessageReceiver* responder_;
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_params(method.response_parameters)}}) const {
-  {{compute_payload_size(params_name, method.response_parameters)}} 
+  {{compute_payload_size(params_name, method.response_parameters)}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, payload_size, request_id_);
-  {{build_message(params_name, method.response_parameters)}} 
+  {{build_message(params_name, method.response_parameters)}}
   responder_->Accept(&message);
   delete responder_;
   responder_ = NULL;
 }
-{%-   endif -%} 
+{%-   endif -%}
 {%- endfor %}
 
 {{class_name}}Stub::{{class_name}}Stub({{class_name}}* sink)
     : sink_(sink) {
 }
 
 {#--- 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 %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       if (!params->DecodePointersAndHandles(message))
         return false;
       sink_->{{method.name}}({{pass_params(method.parameters)}});
       params->CloseHandles();
       return true;
 {%-     else %}
       break;
-{%-     endif %} 
+{%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 bool {{class_name}}Stub::AcceptWithResponder(
     mojo::Message* message, mojo::MessageReceiver* responder) {
 {%- if interface.methods %}
@@ skipping 10 matching lines @@
       {{interface_macros.declare_callback(method)}}::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(), responder);
       {{interface_macros.declare_callback(method)}} callback(runnable);
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       params->CloseHandles();
       return true;
 {%-     else %}
       break;
-{%-     endif %} 
+{%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }