dbus: Add API for array of ints

This change adds API to append and pop an array of signed / unsigned
integers.

BUG=chromium:845696
TEST=Add and run unit tests.

Change-Id: Ib1cabdc8b442b549e27701a804c16114f4ae9582
Reviewed-on: https://chromium-review.googlesource.com/1069714
Commit-Queue: Abhishek Bhardwaj <abhishekbh@chromium.org>
Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#564184}

dbus/message.cc

@@ -576,6 +576,29 @@ void MessageWriter::AppendArrayOfBytes(const uint8_t* values, size_t length) {
   CloseContainer(&array_writer);
 }
 
+void MessageWriter::AppendArrayOfInt32s(const int32_t* values, size_t length) {
+  DCHECK(!container_is_open_);
+  MessageWriter array_writer(message_);
+  OpenArray("i", &array_writer);
+  const bool success = dbus_message_iter_append_fixed_array(
+      &(array_writer.raw_message_iter_), DBUS_TYPE_INT32, &values,
+      static_cast<int>(length));
+  CHECK(success) << "Unable to allocate memory";
+  CloseContainer(&array_writer);
+}
+
+void MessageWriter::AppendArrayOfUint32s(const uint32_t* values,
+                                         size_t length) {
+  DCHECK(!container_is_open_);
+  MessageWriter array_writer(message_);
+  OpenArray("u", &array_writer);
+  const bool success = dbus_message_iter_append_fixed_array(
+      &(array_writer.raw_message_iter_), DBUS_TYPE_UINT32, &values,
+      static_cast<int>(length));
+  CHECK(success) << "Unable to allocate memory";
+  CloseContainer(&array_writer);
+}
+
 void MessageWriter::AppendArrayOfDoubles(const double* values, size_t length) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
@@ -804,6 +827,46 @@ bool MessageReader::PopArrayOfBytes(const uint8_t** bytes, size_t* length) {
   return true;
 }
 
+bool MessageReader::PopArrayOfInt32s(const int32_t** signed_ints,
+                                     size_t* length) {
+  MessageReader array_reader(message_);
+  if (!PopArray(&array_reader))
+    return false;
+  // An empty array is allowed.
+  if (!array_reader.HasMoreData()) {
+    *length = 0;
+    *signed_ints = nullptr;
+    return true;
+  }
+  if (!array_reader.CheckDataType(DBUS_TYPE_INT32))
+    return false;
+  int int_length = 0;
+  dbus_message_iter_get_fixed_array(&array_reader.raw_message_iter_,
+                                    signed_ints, &int_length);
+  *length = static_cast<size_t>(int_length);
+  return true;
+}
+
+bool MessageReader::PopArrayOfUint32s(const uint32_t** unsigned_ints,
+                                      size_t* length) {
+  MessageReader array_reader(message_);
+  if (!PopArray(&array_reader))
+    return false;
+  // An empty array is allowed.
+  if (!array_reader.HasMoreData()) {
+    *length = 0;
+    *unsigned_ints = nullptr;
+    return true;
+  }
+  if (!array_reader.CheckDataType(DBUS_TYPE_UINT32))
+    return false;
+  int int_length = 0;
+  dbus_message_iter_get_fixed_array(&array_reader.raw_message_iter_,
+                                    unsigned_ints, &int_length);
+  *length = static_cast<size_t>(int_length);
+  return true;
+}
+
 bool MessageReader::PopArrayOfDoubles(const double** doubles, size_t* length) {
   MessageReader array_reader(message_);
   if (!PopArray(&array_reader))

dbus/message.h

@@ -312,6 +312,12 @@ class CHROME_DBUS_EXPORT MessageWriter {
   // function.
   void AppendArrayOfBytes(const uint8_t* values, size_t length);
 
+  // Appends array of int32_ts.
+  void AppendArrayOfInt32s(const int32_t* values, size_t length);
+
+  // Appends array of uint32_ts.
+  void AppendArrayOfUint32s(const uint32_t* values, size_t length);
+
   // Appends the array of doubles. Used for audio mixer matrix doubles.
   void AppendArrayOfDoubles(const double* values, size_t length);
 
@@ -418,6 +424,12 @@ class CHROME_DBUS_EXPORT MessageReader {
   // after the MessageReader is destroyed.
   bool PopArrayOfBytes(const uint8_t** bytes, size_t* length);
 
+  // Gets the array of int32_ts at the current iterator position.
+  bool PopArrayOfInt32s(const int32_t** signed_ints, size_t* length);
+
+  // Gets the array of uint32_ts at the current iterator position.
+  bool PopArrayOfUint32s(const uint32_t** unsigned_ints, size_t* length);
+
   // Gets the array of doubles at the current iterator position.
   bool PopArrayOfDoubles(const double** doubles, size_t* length);
 

dbus/message_unittest.cc

@@ -240,6 +240,48 @@ TEST(MessageTest, ArrayOfBytes) {
   EXPECT_EQ(3, output_bytes[2]);
 }
 
+TEST(MessageTest, ArrayOfInt32s) {
+  std::unique_ptr<Response> message(Response::CreateEmpty());
+  MessageWriter writer(message.get());
+  std::vector<int32_t> int32s;
+  int32s.push_back(1);
+  int32s.push_back(2);
+  int32s.push_back(3);
+  writer.AppendArrayOfInt32s(int32s.data(), int32s.size());
+
+  MessageReader reader(message.get());
+  const int32_t* output_int32s = nullptr;
+  size_t length = 0;
+  ASSERT_EQ("ai", reader.GetDataSignature());
+  ASSERT_TRUE(reader.PopArrayOfInt32s(&output_int32s, &length));
+  ASSERT_FALSE(reader.HasMoreData());
+  ASSERT_EQ(3U, length);
+  EXPECT_EQ(1, output_int32s[0]);
+  EXPECT_EQ(2, output_int32s[1]);
+  EXPECT_EQ(3, output_int32s[2]);
+}
+
+TEST(MessageTest, ArrayOfUint32s) {
+  std::unique_ptr<Response> message(Response::CreateEmpty());
+  MessageWriter writer(message.get());
+  std::vector<uint32_t> uint32s;
+  uint32s.push_back(1);
+  uint32s.push_back(2);
+  uint32s.push_back(3);
+  writer.AppendArrayOfUint32s(uint32s.data(), uint32s.size());
+
+  MessageReader reader(message.get());
+  const uint32_t* output_uint32s = nullptr;
+  size_t length = 0;
+  ASSERT_EQ("au", reader.GetDataSignature());
+  ASSERT_TRUE(reader.PopArrayOfUint32s(&output_uint32s, &length));
+  ASSERT_FALSE(reader.HasMoreData());
+  ASSERT_EQ(3U, length);
+  EXPECT_EQ(1U, output_uint32s[0]);
+  EXPECT_EQ(2U, output_uint32s[1]);
+  EXPECT_EQ(3U, output_uint32s[2]);
+}
+
 TEST(MessageTest, ArrayOfDoubles) {
   std::unique_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());