device/bluetooth: Fix Interger type for DBus message construction

device/bluetooth/dbus/bluetooth_adapter_client.cc

 // Copyright 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 "device/bluetooth/dbus/bluetooth_adapter_client.h"
 
+#include <string>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/values.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_manager.h"
 #include "dbus/object_proxy.h"
 #include "dbus/values_util.h"
 #include "device/bluetooth/bluez/bluetooth_service_attribute_value_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_service_record_bluez.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
+void WriteNumberAttribute(dbus::MessageWriter* writer,
+                          const BluetoothServiceAttributeValueBlueZ& attribute,
+                          bool is_signed) {
+  dbus::MessageWriter variant_writer(nullptr);
+  int value;
+
+  attribute.value().GetAsInteger(&value);
+
+  switch (attribute.size()) {
+    case 1:
+      writer->OpenVariant(std::string(1, dbus::Message::DataType::BYTE),

[Rahul Chaturvedi, 2016/08/29 22:00:29]

Instead of doing OpenVariant, then Append and CloseContainer, maybe just use
AppendVariantOfUint32, etc?

[puthik_chromium, 2016/08/29 22:17:10]

Done. Forgot that we have those API.

+                          &variant_writer);
+      if (is_signed)
+        variant_writer.AppendByte(static_cast<int8_t>(value));
+      else
+        variant_writer.AppendByte(static_cast<uint8_t>(value));
+      break;
+    case 2:
+      if (is_signed) {
+        writer->OpenVariant(std::string(1, dbus::Message::DataType::INT16),
+                            &variant_writer);
+        variant_writer.AppendInt16(static_cast<int16_t>(value));
+      } else {
+        writer->OpenVariant(std::string(1, dbus::Message::DataType::UINT16),
+                            &variant_writer);
+        variant_writer.AppendUint16(static_cast<uint16_t>(value));
+      }
+      break;
+    case 4:
+      if (is_signed) {
+        writer->OpenVariant(std::string(1, dbus::Message::DataType::INT32),
+                            &variant_writer);
+        variant_writer.AppendInt32(static_cast<int32_t>(value));
+      } else {
+        writer->OpenVariant(std::string(1, dbus::Message::DataType::UINT32),
+                            &variant_writer);
+        variant_writer.AppendUint32(static_cast<uint32_t>(value));
+      }
+      break;
+    default:
+      NOTREACHED();
+  }
+  writer->CloseContainer(&variant_writer);
+}
+
 void WriteAttribute(dbus::MessageWriter* writer,
                     const BluetoothServiceAttributeValueBlueZ& attribute) {
   dbus::MessageWriter struct_writer(nullptr);
   writer->OpenStruct(&struct_writer);
   struct_writer.AppendByte(attribute.type());
   struct_writer.AppendUint32(attribute.size());
 
-  if (attribute.type() != BluetoothServiceAttributeValueBlueZ::SEQUENCE) {
-    dbus::AppendValueDataAsVariant(&struct_writer, attribute.value());
-  } else {
-    dbus::MessageWriter variant_writer(nullptr);
-    dbus::MessageWriter array_writer(nullptr);
-    struct_writer.OpenVariant("a(yuv)", &variant_writer);
-    variant_writer.OpenArray("(yuv)", &array_writer);
+  switch (attribute.type()) {
+    case bluez::BluetoothServiceAttributeValueBlueZ::UINT:
+      WriteNumberAttribute(&struct_writer, attribute, false);
+      break;
+    case bluez::BluetoothServiceAttributeValueBlueZ::INT:
+      WriteNumberAttribute(&struct_writer, attribute, true);
+      break;
+    case bluez::BluetoothServiceAttributeValueBlueZ::BOOL:
+    case bluez::BluetoothServiceAttributeValueBlueZ::UUID:
+    case bluez::BluetoothServiceAttributeValueBlueZ::STRING:
+    case bluez::BluetoothServiceAttributeValueBlueZ::URL:
+      dbus::AppendValueDataAsVariant(&struct_writer, attribute.value());
+      break;
+    case BluetoothServiceAttributeValueBlueZ::SEQUENCE: {
+      dbus::MessageWriter variant_writer(nullptr);
+      dbus::MessageWriter array_writer(nullptr);
+      struct_writer.OpenVariant("a(yuv)", &variant_writer);
+      variant_writer.OpenArray("(yuv)", &array_writer);
 
-    for (const auto& v : attribute.sequence())
-      WriteAttribute(&array_writer, v);
-    variant_writer.CloseContainer(&array_writer);
-    struct_writer.CloseContainer(&variant_writer);
+      for (const auto& v : attribute.sequence())
+        WriteAttribute(&array_writer, v);
+      variant_writer.CloseContainer(&array_writer);
+      struct_writer.CloseContainer(&variant_writer);
+      break;
+    }
+    case bluez::BluetoothServiceAttributeValueBlueZ::NULLTYPE:
+    default:
+      NOTREACHED();
   }
   writer->CloseContainer(&struct_writer);
 }
 
 }  // namespace
 
 BluetoothAdapterClient::DiscoveryFilter::DiscoveryFilter() {}
 
 BluetoothAdapterClient::DiscoveryFilter::~DiscoveryFilter() {}
 
@@ skipping 393 matching lines @@
 
 BluetoothAdapterClient::BluetoothAdapterClient() {}
 
 BluetoothAdapterClient::~BluetoothAdapterClient() {}
 
 BluetoothAdapterClient* BluetoothAdapterClient::Create() {
   return new BluetoothAdapterClientImpl;
 }
 
 }  // namespace bluez