Allow Chromium's DBus service ownership to be stealable

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 483 matching lines @@
 
   // Wait until the shutdown is complete on the D-Bus thread.
   // The shutdown should not hang, but set timeout just in case.
   const int kTimeoutSecs = 3;
   const base::TimeDelta timeout(base::TimeDelta::FromSeconds(kTimeoutSecs));
   const bool signaled = on_shutdown_.TimedWait(timeout);
   LOG_IF(ERROR, !signaled) << "Failed to shutdown the bus";
 }
 
 void Bus::RequestOwnership(const std::string& service_name,
+                           ServiceOwnershipOptions options,
                            OnOwnershipCallback on_ownership_callback) {
   AssertOnOriginThread();
 
   PostTaskToDBusThread(FROM_HERE, base::Bind(
       &Bus::RequestOwnershipInternal,
-      this, service_name, on_ownership_callback));
+      this, service_name, options, on_ownership_callback));
 }
 
 void Bus::RequestOwnershipInternal(const std::string& service_name,
+                                   ServiceOwnershipOptions options,
                                    OnOwnershipCallback on_ownership_callback) {
   AssertOnDBusThread();
 
   bool success = Connect();
   if (success)
-    success = RequestOwnershipAndBlock(service_name);
+    success = RequestOwnershipAndBlock(service_name, options);
 
   PostTaskToOriginThread(FROM_HERE,
                          base::Bind(on_ownership_callback,
                                     service_name,
                                     success));
 }
 
-bool Bus::RequestOwnershipAndBlock(const std::string& service_name) {
+bool Bus::RequestOwnershipAndBlock(const std::string& service_name,
+                                   ServiceOwnershipOptions options) {
   DCHECK(connection_);
   // dbus_bus_request_name() is a blocking call.
   AssertOnDBusThread();
 
   // Check if we already own the service name.
   if (owned_service_names_.find(service_name) != owned_service_names_.end()) {
     return true;
   }
 
   ScopedDBusError error;
   const int result = dbus_bus_request_name(connection_,
                                            service_name.c_str(),
-                                           DBUS_NAME_FLAG_DO_NOT_QUEUE,
+                                           options,
                                            error.get());
   if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
     LOG(ERROR) << "Failed to get the ownership of " << service_name << ": "
                << (error.is_set() ? error.message() : "");
     return false;
   }
   owned_service_names_.insert(service_name);
   return true;
 }
 
@@ skipping 11 matching lines @@
   }
 
   ScopedDBusError error;
   const int result = dbus_bus_release_name(connection_, service_name.c_str(),
                                            error.get());
   if (result == DBUS_RELEASE_NAME_REPLY_RELEASED) {
     owned_service_names_.erase(found);
     return true;
   } else {
     LOG(ERROR) << "Failed to release the ownership of " << service_name << ": "
-               << (error.is_set() ? error.message() : "");
+               << (error.is_set() ? error.message() : "")
+               << ", result code: " << result;
     return false;
   }
 }
 
 bool Bus::SetUpAsyncOperations() {
   DCHECK(connection_);
   AssertOnDBusThread();
 
   if (async_operations_set_up_)
     return true;
@@ skipping 642 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