Allow Chromium's DBus service ownership to be stealable

dbus/test_service.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/test_service.h"
 
 #include "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "dbus/object_manager.h"
 #include "dbus/object_path.h"
 #include "dbus/property.h"
 
 namespace {
 
 void EmptyCallback(bool /* success */) {
 }
 
 }  // namespace
 
 namespace dbus {
 
 // Echo, SlowEcho, AsyncEcho, BrokenMethod, GetAll, Get, Set, PerformAction,
 // GetManagedObjects.
 const int TestService::kNumMethodsToExport = 9;
 
-TestService::Options::Options() {
+TestService::Options::Options()
+    : request_ownership_options(Bus::REQUIRE_PRIMARY) {
 }
 
 TestService::Options::~Options() {
 }
 
 TestService::TestService(const Options& options)
     : base::Thread("TestService"),
+      request_ownership_options_(options.request_ownership_options),
       dbus_task_runner_(options.dbus_task_runner),
       on_all_methods_exported_(false, false),
       num_exported_methods_(0) {
 }
 
 TestService::~TestService() {
   Stop();
 }
 
 bool TestService::StartService() {
@@ skipping 48 matching lines @@
   writer.AppendString(message);
   exported_object_->SendSignal(&signal);
 }
 
 void TestService::SendTestSignalFromRootInternal(const std::string& message) {
   Signal signal("org.chromium.TestInterface", "Test");
   MessageWriter writer(&signal);
   writer.AppendString(message);
 
   bus_->RequestOwnership("org.chromium.TestService",
+                         request_ownership_options_,
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     base::Bind(&EmptyCallback)));
 
   // Use "/" just like dbus-send does.
   ExportedObject* root_object = bus_->GetExportedObject(ObjectPath("/"));
   root_object->SendSignal(&signal);
 }
 
 void TestService::RequestOwnership(base::Callback<void(bool)> callback) {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::RequestOwnershipInternal,
                  base::Unretained(this),
                  callback));
 }
 
 void TestService::RequestOwnershipInternal(
     base::Callback<void(bool)> callback) {
   bus_->RequestOwnership("org.chromium.TestService",
+                         request_ownership_options_,
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     callback));
 }
 
 void TestService::OnOwnership(base::Callback<void(bool)> callback,
                               const std::string& service_name,
                               bool success) {
   has_ownership_ = success;
   LOG_IF(ERROR, !success) << "Failed to own: " << service_name;
@@ skipping 17 matching lines @@
 }
 
 void TestService::Run(base::MessageLoop* message_loop) {
   Bus::Options bus_options;
   bus_options.bus_type = Bus::SESSION;
   bus_options.connection_type = Bus::PRIVATE;
   bus_options.dbus_task_runner = dbus_task_runner_;
   bus_ = new Bus(bus_options);
 
   bus_->RequestOwnership("org.chromium.TestService",
+                         request_ownership_options_,
                          base::Bind(&TestService::OnOwnership,
                                     base::Unretained(this),
                                     base::Bind(&EmptyCallback)));
 
   exported_object_ = bus_->GetExportedObject(
       ObjectPath("/org/chromium/TestObject"));
 
   int num_methods = 0;
   exported_object_->ExportMethod(
       "org.chromium.TestInterface",
@@ skipping 429 matching lines @@
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString("Name");
   dict_entry_writer.AppendVariantOfString(name);
   array_writer.CloseContainer(&dict_entry_writer);
   writer.CloseContainer(&array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 }  // namespace dbus