dbus: Use randomly generated string as a TestService's service name

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 <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/guid.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 {
@@ skipping 11 matching lines @@
 
 TestService::Options::Options()
     : request_ownership_options(Bus::REQUIRE_PRIMARY) {
 }
 
 TestService::Options::~Options() {
 }
 
 TestService::TestService(const Options& options)
     : base::Thread("TestService"),
+      service_name_(options.service_name),
       request_ownership_options_(options.request_ownership_options),
       dbus_task_runner_(options.dbus_task_runner),
       on_name_obtained_(false, false),
       num_exported_methods_(0),
       send_immediate_properties_changed_(false),
       has_ownership_(false),
       exported_object_(NULL),
       exported_object_manager_(NULL) {
+  if (service_name_.empty()) {
+    service_name_ = "org.chromium.TestService-" + base::GenerateGUID();
+  }
 }
 
 TestService::~TestService() {
   Stop();
 }
 
 bool TestService::StartService() {
   base::Thread::Options thread_options;
   thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
   return StartWithOptions(thread_options);
@@ skipping 44 matching lines @@
   MessageWriter writer(&signal);
   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",
+  bus_->RequestOwnership(service_name_,
                          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",
+  bus_->RequestOwnership(service_name_,
                          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;
   callback.Run(success);
 
   on_name_obtained_.Signal();
 }
 
 void TestService::ReleaseOwnership(base::Closure callback) {
   bus_->GetDBusTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&TestService::ReleaseOwnershipInternal,
                  base::Unretained(this),
                  callback));
 }
 
 void TestService::ReleaseOwnershipInternal(
     base::Closure callback) {
-  bus_->ReleaseOwnership("org.chromium.TestService");
+  bus_->ReleaseOwnership(service_name_);
   has_ownership_ = false;
 
   bus_->GetOriginTaskRunner()->PostTask(
       FROM_HERE,
       callback);
 }
 
 void TestService::SetSendImmediatePropertiesChanged() {
   send_immediate_properties_changed_ = true;
 }
 
 void TestService::OnExported(const std::string& interface_name,
                              const std::string& method_name,
                              bool success) {
   if (!success) {
     LOG(ERROR) << "Failed to export: " << interface_name << "."
                << method_name;
     // Returning here will make WaitUntilServiceIsStarted() to time out
     // and return false.
     return;
   }
 
   ++num_exported_methods_;
   if (num_exported_methods_ == kNumMethodsToExport) {
     // As documented in exported_object.h, the service name should be
     // requested after all methods are exposed.
-    bus_->RequestOwnership("org.chromium.TestService",
+    bus_->RequestOwnership(service_name_,
                            request_ownership_options_,
                            base::Bind(&TestService::OnOwnership,
                                       base::Unretained(this),
                                       base::Bind(&EmptyCallback)));
   }
 }
 
 void TestService::Run(base::MessageLoop* message_loop) {
   Bus::Options bus_options;
   bus_options.bus_type = Bus::SESSION;
@@ skipping 535 matching lines @@
   MessageWriter invalidated_array_writer(NULL);
 
   writer.OpenArray("s", &invalidated_array_writer);
   invalidated_array_writer.AppendString("Name");
   writer.CloseContainer(&invalidated_array_writer);
 
   exported_object_->SendSignal(&signal);
 }
 
 }  // namespace dbus