base: Remove the string logging from CHECK().

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/format_macros.h"
 #include "base/logging.h"
@@ skipping 518 matching lines @@
 // not be a big issue.
 void MessageWriter::OpenArray(const std::string& signature,
                               MessageWriter* writer) {
   DCHECK(!container_is_open_);
 
   const bool success = dbus_message_iter_open_container(
       &raw_message_iter_,
       DBUS_TYPE_ARRAY,
       signature.c_str(),
       &writer->raw_message_iter_);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   container_is_open_ = true;
 }
 
 void MessageWriter::OpenVariant(const std::string& signature,
                                 MessageWriter* writer) {
   DCHECK(!container_is_open_);
 
   const bool success = dbus_message_iter_open_container(
       &raw_message_iter_,
       DBUS_TYPE_VARIANT,
       signature.c_str(),
       &writer->raw_message_iter_);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   container_is_open_ = true;
 }
 
 void MessageWriter::OpenStruct(MessageWriter* writer) {
   DCHECK(!container_is_open_);
 
   const bool success = dbus_message_iter_open_container(
       &raw_message_iter_,
       DBUS_TYPE_STRUCT,
       NULL,  // Signature should be NULL.
       &writer->raw_message_iter_);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   container_is_open_ = true;
 }
 
 void MessageWriter::OpenDictEntry(MessageWriter* writer) {
   DCHECK(!container_is_open_);
 
   const bool success = dbus_message_iter_open_container(
       &raw_message_iter_,
       DBUS_TYPE_DICT_ENTRY,
       NULL,  // Signature should be NULL.
       &writer->raw_message_iter_);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   container_is_open_ = true;
 }
 
 void MessageWriter::CloseContainer(MessageWriter* writer) {
   DCHECK(container_is_open_);
 
   const bool success = dbus_message_iter_close_container(
       &raw_message_iter_, &writer->raw_message_iter_);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   container_is_open_ = false;
 }
 
 void MessageWriter::AppendArrayOfBytes(const uint8_t* values, size_t length) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("y", &array_writer);
   const bool success = dbus_message_iter_append_fixed_array(
       &(array_writer.raw_message_iter_),
       DBUS_TYPE_BYTE,
       &values,
       static_cast<int>(length));
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   CloseContainer(&array_writer);
 }
 
 void MessageWriter::AppendArrayOfDoubles(const double* values, size_t length) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("d", &array_writer);
   const bool success = dbus_message_iter_append_fixed_array(
       &(array_writer.raw_message_iter_),
       DBUS_TYPE_DOUBLE,
       &values,
       static_cast<int>(length));
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   CloseContainer(&array_writer);
 }
 
 void MessageWriter::AppendArrayOfStrings(
     const std::vector<std::string>& strings) {
   DCHECK(!container_is_open_);
   MessageWriter array_writer(message_);
   OpenArray("s", &array_writer);
   for (size_t i = 0; i < strings.size(); ++i) {
     array_writer.AppendString(strings[i]);
@@ skipping 73 matching lines @@
 }
 
 void MessageWriter::AppendBasic(int dbus_type, const void* value) {
   DCHECK(!container_is_open_);
 
   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";
+  // Unable to allocate memory
+  CHECK(success);
 }
 
 void MessageWriter::AppendVariantOfBasic(int dbus_type, const void* value) {
   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);
 }
@@ skipping 300 matching lines @@
   int fd = -1;
   const bool success = PopBasic(DBUS_TYPE_UNIX_FD, &fd);
   if (!success)
     return false;
 
   *value = base::ScopedFD(fd);
   return true;
 }
 
 }  // namespace dbus