Allow Chromium's DBus service ownership to be stealable

dbus/bus.h

 // 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.
 
 #ifndef DBUS_BUS_H_
 #define DBUS_BUS_H_
 
 #include <dbus/dbus.h>
 
 #include <map>
@@ skipping 150 matching lines @@
     SHARED,
   };
 
   // Specifies whether the GetServiceOwnerAndBlock call should report or
   // suppress errors.
   enum GetServiceOwnerOption {
     REPORT_ERRORS,
     SUPPRESS_ERRORS,
   };
 
+  // Specifies service ownership options.
+  //
+  // REQUIRE_PRIMARY indicates that you require primary ownership of the
+  // service name.
+  //
+  // ALLOW_REPLACEMENT indicates that you'll allow another connection to
+  // steal ownership of this service name from you.
+  //
+  // REQUIRE_PRIMARY_ALLOW_REPLACEMENT does the obvious.
+  enum ServiceOwnershipOptions {
+    REQUIRE_PRIMARY = (DBUS_NAME_FLAG_DO_NOT_QUEUE |
+                       DBUS_NAME_FLAG_REPLACE_EXISTING),
+    ALLOW_REPLACEMENT = DBUS_NAME_FLAG_ALLOW_REPLACEMENT,

[satorux1, 2013/07/26 00:50:12]

Don't we need DBUS_NAME_FLAG_DO_NOT_QUEUE for this? I think we rarely want to
wait in the queue.

That said, simply copying the libdbus constants would be more straightforward:

enum ServiceOwnershipOptions {
  ALLOW_REPLACEMENT = DBUS_NAME_FLAG_ALLOW_REPLACEMENT,
  REPLACE_EXISTING = DBUS_NAME_FLAG_REPLACE_EXISTING,
  DO_NOT_QUEUE = DBUS_NAME_FLAG_DO_NOT_QUEUE,
}

Then RequestOwnership() would take 'int options' which is an OR'ed value of
ServiceOwnershipOptions.

[Chris Masone, 2013/07/26 01:00:24]

I thought about doing that, but wasn't sure if it made sense to have callers be
OR'ing together enum values.  That only works when the values are 0x1, 0x2, 0x4
etc (which they are here), but that's sort of an implementation detail.  That
was why I went with these semantically higher-level enum's.  I'm not married to
this approach, though, if you think that the other way is better.

[satorux1, 2013/07/26 01:14:45]

That's a good point. I think ALLOW_REPLACEMENT alone won't be used in the
caller, so what about just providing the two options:

enum ServiceOwnershipOptions {
  REQUIRE_PRIMARY = (DBUS_NAME_FLAG_DO_NOT_QUEUE |
DBUS_NAME_FLAG_REPLACE_EXISTING),
  REQUIRE_PRIMARY_ALLOW_REPLACEMENT = (REQUIRE_PRIMARY |
DBUS_NAME_FLAG_ALLOW_REPLACEMENT)
}

This would suffice for now. We can switch to the OR-ed value approach if needed
at a later time.

[Chris Masone, 2013/07/26 17:37:24]

Done.

+    REQUIRE_PRIMARY_ALLOW_REPLACEMENT = REQUIRE_PRIMARY | ALLOW_REPLACEMENT,
+  };
+
   // Options used to create a Bus object.
   struct CHROME_DBUS_EXPORT Options {
     Options();
     ~Options();
 
     BusType bus_type;  // SESSION by default.
     ConnectionType connection_type;  // PRIVATE by default.
     // If dbus_task_runner is set, the bus object will use that
     // task runner to process asynchronous operations.
     //
@@ skipping 210 matching lines @@
   virtual void ClosePrivateConnection();
 
   // Requests the ownership of the service name given by |service_name|.
   // See also RequestOwnershipAndBlock().
   //
   // |on_ownership_callback| is called when the service name is obtained
   // or failed to be obtained, in the origin thread.
   //
   // Must be called in the origin thread.
   virtual void RequestOwnership(const std::string& service_name,
+                                ServiceOwnershipOptions options,
                                 OnOwnershipCallback on_ownership_callback);
 
   // Requests the ownership of the given service name.
   // Returns true on success, or the the service name is already obtained.
   //
   // BLOCKING CALL.
-  virtual bool RequestOwnershipAndBlock(const std::string& service_name);
+  virtual bool RequestOwnershipAndBlock(const std::string& service_name,
+                                        ServiceOwnershipOptions options);
 
   // Releases the ownership of the given service name.
   // Returns true on success.
   //
   // BLOCKING CALL.
   virtual bool ReleaseOwnership(const std::string& service_name);
 
   // Sets up async operations.
   // Returns true on success, or it's already set up.
   // This function needs to be called before starting async operations.
@@ skipping 183 matching lines @@
 
   // Helper function used for UnregisterExportedObject().
   void UnregisterExportedObjectInternal(
       scoped_refptr<dbus::ExportedObject> exported_object);
 
   // Helper function used for ShutdownOnDBusThreadAndBlock().
   void ShutdownOnDBusThreadAndBlockInternal();
 
   // Helper function used for RequestOwnership().
   void RequestOwnershipInternal(const std::string& service_name,
+                                ServiceOwnershipOptions options,
                                 OnOwnershipCallback on_ownership_callback);
 
   // Helper function used for GetServiceOwner().
   void GetServiceOwnerInternal(const std::string& service_name,
                                const GetServiceOwnerCallback& callback);
 
   // Helper function used for ListenForServiceOwnerChange().
   void ListenForServiceOwnerChangeInternal(
       const std::string& service_name,
       const GetServiceOwnerCallback& callback);
@@ skipping 124 matching lines @@
 
   std::string address_;
   base::Closure on_disconnected_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(Bus);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_BUS_H_