Use unions for interface control messages.

mojo/public/cpp/bindings/lib/control_message_handler.cc

Index: mojo/public/cpp/bindings/lib/control_message_handler.cc
diff --git a/mojo/public/cpp/bindings/lib/control_message_handler.cc b/mojo/public/cpp/bindings/lib/control_message_handler.cc
index 75388d105e376ee73c65ef25759cb179b9fed7dc..b8ebe310a914277614a9d81e76dc3596f7816e2f 100644
--- a/mojo/public/cpp/bindings/lib/control_message_handler.cc
+++ b/mojo/public/cpp/bindings/lib/control_message_handler.cc
@@ -18,8 +18,8 @@ namespace internal {
 
 // static
 bool ControlMessageHandler::IsControlMessage(const Message* message) {
-  return message->header()->name == kRunMessageId ||
-         message->header()->name == kRunOrClosePipeMessageId;
+  return message->header()->name == interface_control::kRunMessageId ||
+         message->header()->name == interface_control::kRunOrClosePipeMessageId;
 }
 
 ControlMessageHandler::ControlMessageHandler(uint32_t interface_version)
@@ -30,7 +30,7 @@ ControlMessageHandler::~ControlMessageHandler() {
 }
 
 bool ControlMessageHandler::Accept(Message* message) {
-  if (message->header()->name == kRunOrClosePipeMessageId)
+  if (message->header()->name == interface_control::kRunOrClosePipeMessageId)
     return RunOrClosePipe(message);
 
   NOTREACHED();
@@ -40,7 +40,7 @@ bool ControlMessageHandler::Accept(Message* message) {
 bool ControlMessageHandler::AcceptWithResponder(
     Message* message,
     MessageReceiverWithStatus* responder) {
-  if (message->header()->name == kRunMessageId)
+  if (message->header()->name == interface_control::kRunMessageId)
     return Run(message, responder);
 
   NOTREACHED();
@@ -49,19 +49,33 @@ bool ControlMessageHandler::AcceptWithResponder(
 
 bool ControlMessageHandler::Run(Message* message,
                                 MessageReceiverWithStatus* responder) {
-  RunResponseMessageParamsPtr response_params_ptr(
-      RunResponseMessageParams::New());
-  response_params_ptr->reserved0 = 16u;
-  response_params_ptr->reserved1 = 0u;
-  response_params_ptr->query_version_result = QueryVersionResult::New();
-  response_params_ptr->query_version_result->version = interface_version_;
-
-  size_t size = PrepareToSerialize<RunResponseMessageParamsDataView>(
-      response_params_ptr, &context_);
-  ResponseMessageBuilder builder(kRunMessageId, size, message->request_id());
-
-  RunResponseMessageParams_Data* response_params = nullptr;
-  Serialize<RunResponseMessageParamsDataView>(
+  interface_control::internal::RunMessageParams_Data* params =
+      reinterpret_cast<interface_control::internal::RunMessageParams_Data*>(
+          message->mutable_payload());
+  interface_control::RunMessageParamsPtr params_ptr;
+  Deserialize<interface_control::RunMessageParamsDataView>(params, &params_ptr,
+                                                           &context_);
+  auto& input = *params_ptr->input;
+  auto output = interface_control::RunOutput::New();
+  if (input.is_query_version()) {
+    output->set_query_version_result(
+        interface_control::QueryVersionResult::New());
+    output->get_query_version_result()->version = interface_version_;
+  } else {
+    return false;

[yzshen1, 2016/08/25 21:08:57]

If it is an unknown input, we want to return a null output. That is because we
want to tolerate newer version of control messages. We have this weird union
input/output instead of using separate control message types mostly because of
this. (And please change the Java code as well.)

As a comparison, RunOrClosePipe() closes the pipe if the input is unknown or the
operation fails.

[Sam McNally, 2016/08/25 21:47:50]

Done.

+  }
+
+  auto response_params_ptr = interface_control::RunResponseMessageParams::New();
+  response_params_ptr->output = std::move(output);
+  size_t size =
+      PrepareToSerialize<interface_control::RunResponseMessageParamsDataView>(
+          response_params_ptr, &context_);
+  ResponseMessageBuilder builder(interface_control::kRunMessageId, size,
+                                 message->request_id());
+
+  interface_control::internal::RunResponseMessageParams_Data* response_params =
+      nullptr;
+  Serialize<interface_control::RunResponseMessageParamsDataView>(
       response_params_ptr, builder.buffer(), &response_params, &context_);
   bool ok = responder->Accept(builder.message());
   ALLOW_UNUSED_LOCAL(ok);
@@ -71,14 +85,18 @@ bool ControlMessageHandler::Run(Message* message,
 }
 
 bool ControlMessageHandler::RunOrClosePipe(Message* message) {
-  RunOrClosePipeMessageParams_Data* params =
-      reinterpret_cast<RunOrClosePipeMessageParams_Data*>(
+  interface_control::internal::RunOrClosePipeMessageParams_Data* params =
+      reinterpret_cast<
+          interface_control::internal::RunOrClosePipeMessageParams_Data*>(
           message->mutable_payload());
-  RunOrClosePipeMessageParamsPtr params_ptr;
-  Deserialize<RunOrClosePipeMessageParamsDataView>(params, &params_ptr,
-                                                   &context_);
+  interface_control::RunOrClosePipeMessageParamsPtr params_ptr;
+  Deserialize<interface_control::RunOrClosePipeMessageParamsDataView>(
+      params, &params_ptr, &context_);
+  auto& input = *params_ptr->input;
+  if (input.is_require_version())
+    return interface_version_ >= input.get_require_version()->version;
 
-  return interface_version_ >= params_ptr->require_version->version;
+  return false;
 }
 
 }  // namespace internal