Move more Mojo bindings helpers out of internal namespace

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) %}
   ({{params}})->DecodePointers();
@@ skipping 147 matching lines @@
 {%-   set params_struct = method.param_struct %}
 {%-   set params_description =
           "%s.%s request"|format(interface.name, method.name) %}
 {%-   if method.sync %}
 bool {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_sync_method_params("param_", method)}}) {
   {{struct_macros.get_serialized_size(params_struct, "param_%s",
                                       "&serialization_context_")}}
 
   mojo::internal::RequestMessageBuilder builder({{message_name}}, size,
-                                                mojo::internal::kMessageIsSync);
+                                                mojo::Message::kFlagIsSync);
 
   {{build_message(params_struct, "param_%s", params_description,
                   "&serialization_context_")}}
 
   bool result = false;
   mojo::MessageReceiver* responder =
       new {{class_name}}_{{method.name}}_HandleSyncResponse(
           serialization_context_.group_controller, &result
 {%-     for param in method.response_parameters -%}
           , param_{{param.name}}
@@ skipping 100 matching lines @@
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_responder_params(
         "in_", method.response_parameters, for_blink)}}) {
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
                                       "&serialization_context_")}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, size, request_id_,
-      is_sync_ ? mojo::internal::kMessageIsSync : 0);
+      is_sync_ ? mojo::Message::kFlagIsSync : 0);
   {{build_message(response_params_struct, "in_%s", params_description,
                   "&serialization_context_")}}
   bool ok = responder_->Accept(builder.message());
   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;
 }
@@ skipping 51 matching lines @@
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       {{alloc_params(method.param_struct, "params", "message",
           "&serialization_context_", "{{class_name}}::{{method.name}}")|
               indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
-              message->has_flag(mojo::internal::kMessageIsSync),
+              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}}");
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       return true;
 {%-     else %}
       break;
@@ skipping 93 matching lines @@
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}