base: Remove the string logging from CHECK().

dbus/bus.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/bus.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 56 matching lines @@
     else if (flags & DBUS_WATCH_READABLE)
       mode = base::MessageLoopForIO::WATCH_READ;
     else if (flags & DBUS_WATCH_WRITABLE)
       mode = base::MessageLoopForIO::WATCH_WRITE;
     else
       NOTREACHED();
 
     const bool persistent = true;  // Watch persistently.
     const bool success = base::MessageLoopForIO::current()->WatchFileDescriptor(
         file_descriptor, persistent, mode, &file_descriptor_watcher_, this);
-    CHECK(success) << "Unable to allocate memory";
+    // Unable to allocate memory
+    CHECK(success);
   }
 
   // Stops watching the underlying file descriptor.
   void StopWatching() {
     file_descriptor_watcher_.StopWatchingFileDescriptor();
   }
 
  private:
   // Implement MessagePumpLibevent::Watcher.
   void OnFileCanReadWithoutBlocking(int file_descriptor) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_READABLE);
-    CHECK(success) << "Unable to allocate memory";
+    // Unable to allocate memory
+    CHECK(success);
   }
 
   // Implement MessagePumpLibevent::Watcher.
   void OnFileCanWriteWithoutBlocking(int file_descriptor) override {
     const bool success = dbus_watch_handle(raw_watch_, DBUS_WATCH_WRITABLE);
-    CHECK(success) << "Unable to allocate memory";
+    // Unable to allocate memory
+    CHECK(success);
   }
 
   DBusWatch* raw_watch_;
   base::MessagePumpLibevent::FileDescriptorWatcher file_descriptor_watcher_;
 };
 
 // The class is used for monitoring the timeout used for D-Bus method
 // calls.
 //
 // Unlike Watch, Timeout is a ref counted object, to ensure that |this| of
@@ skipping 55 matching lines @@
   void HandleTimeout() {
     // If the timeout is marked completed, we should do nothing. This can
     // occur if this function is called after Bus::OnRemoveTimeout().
     if (is_completed)
       return;
     // Skip if monitoring is canceled.
     if (!monitoring_is_active_)
       return;
 
     const bool success = dbus_timeout_handle(raw_timeout_);
-    CHECK(success) << "Unable to allocate memory";
+    // Unable to allocate memory
+    CHECK(success);
   }
 
   DBusTimeout* raw_timeout_;
   bool monitoring_is_active_;
   bool is_completed;
 };
 
 }  // namespace
 
 Bus::Options::Options()
@@ skipping 444 matching lines @@
   // Process all the incoming data if any, so that OnDispatchStatus() will
   // be called when the incoming data is ready.
   ProcessAllIncomingDataIfAny();
 
   bool success = dbus_connection_set_watch_functions(connection_,
                                                      &Bus::OnAddWatchThunk,
                                                      &Bus::OnRemoveWatchThunk,
                                                      &Bus::OnToggleWatchThunk,
                                                      this,
                                                      NULL);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
 
   success = dbus_connection_set_timeout_functions(connection_,
                                                   &Bus::OnAddTimeoutThunk,
                                                   &Bus::OnRemoveTimeoutThunk,
                                                   &Bus::OnToggleTimeoutThunk,
                                                   this,
                                                   NULL);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
 
   dbus_connection_set_dispatch_status_function(
       connection_,
       &Bus::OnDispatchStatusChangedThunk,
       this,
       NULL);
 
   async_operations_set_up_ = true;
 
   return true;
@@ skipping 10 matching lines @@
 }
 
 void Bus::SendWithReply(DBusMessage* request,
                         DBusPendingCall** pending_call,
                         int timeout_ms) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   const bool success = dbus_connection_send_with_reply(
       connection_, request, pending_call, timeout_ms);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
 }
 
 void Bus::Send(DBusMessage* request, uint32_t* serial) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   const bool success = dbus_connection_send(connection_, request, serial);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
 }
 
 void Bus::AddFilterFunction(DBusHandleMessageFunction filter_function,
                             void* user_data) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   std::pair<DBusHandleMessageFunction, void*> filter_data_pair =
       std::make_pair(filter_function, user_data);
   if (filter_functions_added_.find(filter_data_pair) !=
       filter_functions_added_.end()) {
     VLOG(1) << "Filter function already exists: " << filter_function
             << " with associated data: " << user_data;
     return;
   }
 
   const bool success = dbus_connection_add_filter(
       connection_, filter_function, user_data, NULL);
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   filter_functions_added_.insert(filter_data_pair);
 }
 
 void Bus::RemoveFilterFunction(DBusHandleMessageFunction filter_function,
                                void* user_data) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   std::pair<DBusHandleMessageFunction, void*> filter_data_pair =
       std::make_pair(filter_function, user_data);
@@ skipping 78 matching lines @@
   if (registered_object_paths_.find(object_path) ==
       registered_object_paths_.end()) {
     LOG(ERROR) << "Requested to unregister an unknown object path: "
                << object_path.value();
     return;
   }
 
   const bool success = dbus_connection_unregister_object_path(
       connection_,
       object_path.value().c_str());
-  CHECK(success) << "Unable to allocate memory";
+  // Unable to allocate memory
+  CHECK(success);
   registered_object_paths_.erase(object_path);
 }
 
 void Bus::ShutdownOnDBusThreadAndBlockInternal() {
   AssertOnDBusThread();
 
   ShutdownAndBlock();
   on_shutdown_.Signal();
 }
 
@@ skipping 397 matching lines @@
                              kNameOwnerChangedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->OnServiceOwnerChanged(message);
   }
   // Always return unhandled to let others, e.g. ObjectProxies, handle the same
   // signal.
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus