IntToString() signedness fixes for //dbus

dbus/message.cc

 // Copyright (c) 2012 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 "dbus/message.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "dbus/object_path.h"
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/message_lite.h>
 #else
 #include "third_party/protobuf/src/google/protobuf/message_lite.h"
 #endif
 
 namespace {
 
 // Appends the header name and the value to |output|, if the value is
 // not empty.
 void AppendStringHeader(const std::string& header_name,
                         const std::string& header_value,
                         std::string* output) {
   if (!header_value.empty()) {
     *output += header_name + ": " + header_value + "\n";
   }
 }
 
 // Appends the header name and the value to |output|, if the value is
 // nonzero.
 void AppendUint32Header(const std::string& header_name,
                         uint32 header_value,
                         std::string* output) {
   if (header_value != 0) {
-    *output += (header_name + ": " + base::StringPrintf("%u", header_value) +
-                "\n");
+    *output += (header_name + ": " + base::UintToString(header_value) + "\n");
   }
 }
 
 }  // namespace
 
 namespace dbus {
 
 bool IsDBusTypeUnixFdSupported() {
   int major = 0, minor = 0, micro = 0;
   dbus_get_version(&major, &minor, &micro);
@@ skipping 42 matching lines @@
                                       MessageReader* reader) {
   const char* kBrokenMessage = "[broken message]";
   std::string output;
   while (reader->HasMoreData()) {
     const DataType type = reader->GetDataType();
     switch (type) {
       case BYTE: {
         uint8 value = 0;
         if (!reader->PopByte(&value))
           return kBrokenMessage;
-        output += indent + "byte " + base::IntToString(value) + "\n";
+        output += indent + "byte " + base::UintToString(value) + "\n";
         break;
       }
       case BOOL: {
         bool value = false;
         if (!reader->PopBool(&value))
           return kBrokenMessage;
         output += indent + "bool " + (value ? "true" : "false") + "\n";
         break;
       }
       case INT16: {
         int16 value = 0;
         if (!reader->PopInt16(&value))
           return kBrokenMessage;
         output += indent + "int16 " + base::IntToString(value) + "\n";
         break;
       }
       case UINT16: {
         uint16 value = 0;
         if (!reader->PopUint16(&value))
           return kBrokenMessage;
-        output += indent + "uint16 " + base::IntToString(value) + "\n";
+        output += indent + "uint16 " + base::UintToString(value) + "\n";
         break;
       }
       case INT32: {
         int32 value = 0;
         if (!reader->PopInt32(&value))
           return kBrokenMessage;
         output += indent + "int32 " + base::IntToString(value) + "\n";
         break;
       }
       case UINT32: {
         uint32 value = 0;
         if (!reader->PopUint32(&value))
           return kBrokenMessage;
-        output += indent + "uint32 " + base::StringPrintf("%u", value) + "\n";
+        output += indent + "uint32 " + base::UintToString(value) + "\n";
         break;
       }
       case INT64: {
         int64 value = 0;
         if (!reader->PopInt64(&value))
           return kBrokenMessage;
-        output += (indent + "int64 " +
-                   base::StringPrintf("%" PRId64, value) + "\n");
+        output += (indent + "int64 " + base::Int64ToString(value) + "\n");
         break;
       }
       case UINT64: {
         uint64 value = 0;
         if (!reader->PopUint64(&value))
           return kBrokenMessage;
-        output += (indent + "uint64 " +
-                   base::StringPrintf("%" PRIu64, value) + "\n");
+        output += (indent + "uint64 " + base::Uint64ToString(value) + "\n");
         break;
       }
       case DOUBLE: {
         double value = 0;
         if (!reader->PopDouble(&value))
           return kBrokenMessage;
-        output += indent + "double " + base::StringPrintf("%f", value) + "\n";
+        output += indent + "double " + base::DoubleToString(value) + "\n";
         break;
       }
       case STRING: {
         std::string value;
         if (!reader->PopString(&value))
           return kBrokenMessage;
         // Truncate if the string is longer than the limit.
         const size_t kTruncateLength = 100;
         if (value.size() < kTruncateLength) {
           output += indent + "string \"" + value + "\"\n";
@@ skipping 515 matching lines @@
 
   const bool success = dbus_message_iter_append_basic(
       &raw_message_iter_, dbus_type, value);
   // dbus_message_iter_append_basic() fails only when there is not enough
   // memory. We don't return this error as there is nothing we can do when
   // it fails to allocate memory for a byte etc.
   CHECK(success) << "Unable to allocate memory";
 }
 
 void MessageWriter::AppendVariantOfBasic(int dbus_type, const void* value) {
-  const std::string signature = base::StringPrintf("%c", dbus_type);
+  const std::string signature(1u,  // length
+                              base::checked_cast<char>(dbus_type));
   MessageWriter variant_writer(message_);
   OpenVariant(signature, &variant_writer);
   variant_writer.AppendBasic(dbus_type, value);
   CloseContainer(&variant_writer);
 }
 
 void MessageWriter::AppendFileDescriptor(const FileDescriptor& value) {
   CHECK(IsDBusTypeUnixFdSupported());
 
   if (!value.is_valid()) {
@@ skipping 283 matching lines @@
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   value->PutValue(fd);
   // NB: the caller must check validity before using the value
   return true;
 }
 
 }  // namespace dbus