Minor cleanups and improvements for the D-Bus library.

dbus/bus.cc

 // Copyright (c) 2011 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.
 //
 // TODO(satorux):
 // - Handle "disconnected" signal.
 // - Collect metrics (ex. # of method calls, method call time, etc.)
 
 #include "dbus/bus.h"
 
@@ skipping 164 matching lines @@
 }
 
 Bus::Bus(const Options& options)
     : bus_type_(options.bus_type),
       connection_type_(options.connection_type),
       dbus_thread_(options.dbus_thread),
       connection_(NULL),
       origin_loop_(MessageLoop::current()),
       origin_thread_id_(base::PlatformThread::CurrentId()),
       dbus_thread_id_(base::kInvalidThreadId),
-      async_operations_are_set_up_(false),
+      async_operations_set_up_(false),
       num_pending_watches_(0),
       num_pending_timeouts_(0) {
   if (dbus_thread_) {
     dbus_thread_id_ = dbus_thread_->thread_id();
     DCHECK(dbus_thread_->IsRunning())
         << "The D-Bus thread should be running";
     DCHECK_EQ(MessageLoop::TYPE_IO,
               dbus_thread_->message_loop()->type())
         << "The D-Bus thread should have an MessageLoopForIO attached";
   }
@@ skipping 167 matching lines @@
     LOG(ERROR) << "Failed to release the onwership of " << service_name << ": "
                << (error.is_set() ? error.message() : "");
     return false;
   }
 }
 
 bool Bus::SetUpAsyncOperations() {
   DCHECK(connection_);
   AssertOnDBusThread();
 
-  if (async_operations_are_set_up_)
+  if (async_operations_set_up_)
     return true;
 
   // 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";
 
   // TODO(satorux): Timeout is not yet implemented.
   success = dbus_connection_set_timeout_functions(connection_,
                                                   &Bus::OnAddTimeoutThunk,
                                                   &Bus::OnRemoveTimeoutThunk,
                                                   &Bus::OnToggleTimeoutThunk,
                                                   this,
                                                   NULL);
   CHECK(success) << "Unable to allocate memory";
 
   dbus_connection_set_dispatch_status_function(
       connection_,
       &Bus::OnDispatchStatusChangedThunk,
       this,
       NULL);
 
-  async_operations_are_set_up_ = true;
+  async_operations_set_up_ = true;
 
   return true;
 }
 
 DBusMessage* Bus::SendWithReplyAndBlock(DBusMessage* request,
                                         int timeout_ms,
                                         DBusError* error) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
@@ skipping 79 matching lines @@
   match_rules_added_.erase(match_rule);
 }
 
 bool Bus::TryRegisterObjectPath(const std::string& object_path,
                                 const DBusObjectPathVTable* vtable,
                                 void* user_data,
                                 DBusError* error) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
-  DCHECK(registered_object_paths_.find(object_path) ==
-         registered_object_paths_.end())
-      << "Object path already registered: " << object_path;
+  if (registered_object_paths_.find(object_path) !=
+      registered_object_paths_.end()) {
+    LOG(ERROR) << "Object path already registered: " << object_path;
+    return false;
+  }
 
   const bool success = dbus_connection_try_register_object_path(
       connection_,
       object_path.c_str(),
       vtable,
       user_data,
       error);
   if (success)
     registered_object_paths_.insert(object_path);
   return success;
 }
 
 void Bus::UnregisterObjectPath(const std::string& object_path) {
   DCHECK(connection_);
   AssertOnDBusThread();
 
-  DCHECK(registered_object_paths_.find(object_path) !=
-         registered_object_paths_.end())
-      << "Requested to unregister an unknown object path: " << object_path;
+  if (registered_object_paths_.find(object_path) ==
+      registered_object_paths_.end()) {
+    LOG(ERROR) << "Requested to unregister an unknown object path: "
+               << object_path;
+    return;
+  }
 
   const bool success = dbus_connection_unregister_object_path(
       connection_,
       object_path.c_str());
   CHECK(success) << "Unable to allocate memory";
   registered_object_paths_.erase(object_path);
 }
 
 void Bus::ShutdownInternal(OnShutdownCallback callback) {
   AssertOnDBusThread();
@@ skipping 170 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus