mojo: MessageBuilder

mojo/ipc/message/ipc_message_builder.cc

Index: mojo/ipc/message/ipc_message_builder.cc
diff --git a/mojo/ipc/message/ipc_message_builder.cc b/mojo/ipc/message/ipc_message_builder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..733d6a08bb53f73ffbb2f7e92a58a8f960317891
--- /dev/null
+++ b/mojo/ipc/message/ipc_message_builder.cc
@@ -0,0 +1,177 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "mojo/ipc/message/ipc_message_builder.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits>
+
+#include "mojo/ipc/message/ipc_message.h"
+
+namespace mojo {
+namespace {
+
+// Aligns 'value' by rounding it up to the next multiple of 'alignment'
+uint32_t AlignInt(uint32_t value, uint32_t alignment) {
+  return value + (alignment - (value % alignment)) % alignment;
+}
+
+}  // namespace
+
+IPCMessageBuilder::IPCMessageBuilder() {
+}
+
+IPCMessageBuilder::~IPCMessageBuilder() {
+}
+
+bool IPCMessageBuilder::Initialize(uint32_t type) {
+  uint32_t message_header[2] = {
+    type,
+    0  // Length in bytes to be filled out in Finish.
+  };
+  return AppendRawBytes(&message_header, sizeof(message_header));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, int8_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Int8,
+                   static_cast<uint32_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, int16_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Int16,
+                   static_cast<uint32_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, int32_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Int32,
+                   static_cast<uint32_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, int64_t value) {
+  return AppendU64(name, kIPCMessageFieldType_Int64,
+                   static_cast<uint64_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, uint8_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Uint8,
+                   static_cast<uint32_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, uint16_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Uint16,
+                   static_cast<uint32_t>(value));
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, uint32_t value) {
+  return AppendU32(name, kIPCMessageFieldType_Uint32, value);
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, uint64_t value) {
+  return AppendU64(name, kIPCMessageFieldType_Uint32, value);
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, const std::string& value) {
+  return AppendVariableLength(name, kIPCMessageFieldType_String, value.data(),
+                              value.size());
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, const void* bytes,
+                               size_t num_bytes) {
+  return AppendVariableLength(name, kIPCMessageFieldType_Bytes, bytes,
+                              num_bytes);
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, Handle handle) {
+  if (!AppendU32(name, kIPCMessageFieldType_Handle, handle.value))

[vtl, 2013/09/11 17:37:16]

handle.value isn't going to be a universal (cross-process) thing, but probably
you should append its index into handles_?

+    return false;
+
+  handles_.push_back(handle);
+  return true;
+}
+
+bool IPCMessageBuilder::Append(uint16_t name, const IPCMessage& message) {
+  if (!AppendVariableLength(name, kIPCMessageFieldType_Message,
+                            &message.data()[0], message.data().size()))
+    return false;
+
+  size_t size_before = handles_.size();
+  handles_.insert(handles_.end(),
+                  message.handles().begin(),
+                  message.handles().end());
+
+  // TODO(darin): Should we even worry about memory allocation failure?
+  return handles_.size() == size_before + message.handles().size();
+}
+
+bool IPCMessageBuilder::Finish(IPCMessage* message) {
+  if (data_.empty())  // Initialize was not called!
+    return false;
+
+  uint32_t payload_size = data_.size() - 2U*sizeof(uint32_t);
+  assert(payload_size < data_.size());
+
+  // Stamp payload size into the message.
+  reinterpret_cast<uint32_t*>(&data_[0])[1] = payload_size;
+
+  message->data_.swap(data_);
+  message->handles_.swap(handles_);
+  return true;
+}
+
+bool IPCMessageBuilder::AppendU32(uint16_t name, IPCMessageFieldType field_type,
+                                  uint32_t value) {
+  return AppendHeader(name, field_type) &&
+         AppendRawBytes(&value, sizeof(value));
+}
+
+bool IPCMessageBuilder::AppendU64(uint16_t name, IPCMessageFieldType field_type,
+                                  uint64_t value) {
+  return AppendHeader(name, field_type) &&
+         AppendRawBytes(&value, sizeof(value));
+}
+
+bool IPCMessageBuilder::AppendVariableLength(uint16_t name,
+                                             IPCMessageFieldType field_type,
+                                             const void* bytes,
+                                             size_t num_bytes) {
+  if (num_bytes > std::numeric_limits<uint32_t>::max())
+    return false;
+
+  uint32_t size = static_cast<uint32_t>(num_bytes);
+  uint32_t aligned_size = AlignInt(size, 4U);
+
+  const uint8_t kNulls[4] = { 0 };
+
+  return AppendHeader(name, field_type) &&
+         AppendRawBytes(&size, sizeof(size)) &&
+         AppendRawBytes(bytes, size) &&
+         AppendRawBytes(kNulls, aligned_size - size);
+}
+
+bool IPCMessageBuilder::AppendHeader(uint16_t name,
+                                     IPCMessageFieldType field_type) {
+  uint32_t header = static_cast<uint32_t>(name) << 16 |
+                    static_cast<uint32_t>(field_type);
+  return AppendRawBytes(&header, sizeof(header));
+}
+
+bool IPCMessageBuilder::AppendRawBytes(const void* bytes, size_t num_bytes) {
+  if (!num_bytes)
+    return true;
+
+  const uint8_t* data_start = static_cast<const uint8_t*>(bytes);
+  const uint8_t* data_end = data_start + num_bytes;
+
+  size_t size_before = data_.size();
+
+  // TODO(darin): Call reserve() here?
+  data_.insert(data_.end(), data_start, data_end);
+
+  // TODO(darin): Should we even worry about memory allocation failure?
+  return data_.size() == size_before + num_bytes;
+}
+
+}  // namespace mojo