Add a method to check if a D-Bus service has an owner. Use it for mtpd.

device/media_transfer_protocol/media_transfer_protocol_manager.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 "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 
 #include <map>
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_checker.h"
+#include "dbus/object_proxy.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_daemon_client.h"
 #include "device/media_transfer_protocol/mtp_file_entry.pb.h"
 #include "device/media_transfer_protocol/mtp_storage_info.pb.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
 #else
 #include "dbus/bus.h"
 #endif
 
 namespace device {
 
 namespace {
 
 MediaTransferProtocolManager* g_media_transfer_protocol_manager = NULL;
 
+typedef base::Callback<void(dbus::Bus*, bool)> ServiceHasOwnerCallback;
+
+void CheckMtpdServiceHasOwnerOnDBusThread(
+    scoped_refptr<dbus::Bus> bus,
+    const ServiceHasOwnerCallback& reply_task) {
+  bool has_owner =
+      dbus::ObjectProxy::ServiceHasOwner(bus, mtpd::kMtpdServiceName);
+  bus->PostTaskToOriginThread(FROM_HERE,
+                              base::Bind(reply_task, bus, has_owner));
+}
+
 // The MediaTransferProtocolManager implementation.
 class MediaTransferProtocolManagerImpl : public MediaTransferProtocolManager {
  public:
   explicit MediaTransferProtocolManagerImpl(
       scoped_refptr<base::SequencedTaskRunner> task_runner)
       : weak_ptr_factory_(this) {
     dbus::Bus* bus = NULL;
 #if defined(OS_CHROMEOS)
     DCHECK(!task_runner.get());
     chromeos::DBusThreadManager* dbus_thread_manager =
         chromeos::DBusThreadManager::Get();
     bus = dbus_thread_manager->GetSystemBus();
     if (!bus)
       return;
 #else
     DCHECK(task_runner.get());
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
     options.connection_type = dbus::Bus::PRIVATE;
     options.dbus_task_runner = task_runner;
     session_bus_ = new dbus::Bus(options);
     bus = session_bus_.get();
 #endif
 
     DCHECK(bus);
-    mtp_client_.reset(
-        MediaTransferProtocolDaemonClient::Create(bus, false /* not stub */));
 
-    // Set up signals and start initializing |storage_info_map_|.
-    mtp_client_->SetUpConnections(
-        base::Bind(&MediaTransferProtocolManagerImpl::OnStorageChanged,
-                   weak_ptr_factory_.GetWeakPtr()));
-    mtp_client_->EnumerateStorages(
-        base::Bind(&MediaTransferProtocolManagerImpl::OnEnumerateStorages,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&base::DoNothing));
+    ServiceHasOwnerCallback reply_task =
+        base::Bind(&MediaTransferProtocolManagerImpl::FinishSetupOnOriginThread,
+                   weak_ptr_factory_.GetWeakPtr());
+    base::Closure dbus_task = base::Bind(&CheckMtpdServiceHasOwnerOnDBusThread,
+                                         make_scoped_refptr(bus),
+                                         reply_task);
+    bus->PostTaskToDBusThread(FROM_HERE, dbus_task);

[satorux1, 2013/04/30 01:53:10]

This is awkward. I think we should provide an asynchronous utility function in
'dbus', so clients don't have to deal with posting something to the D-Bus
thread.

   }
 
   virtual ~MediaTransferProtocolManagerImpl() {
     DCHECK(g_media_transfer_protocol_manager);
     g_media_transfer_protocol_manager = NULL;
     VLOG(1) << "MediaTransferProtocolManager Shutdown completed";
   }
 
   // MediaTransferProtocolManager override.
   virtual void AddObserver(Observer* observer) OVERRIDE {
@@ skipping 313 matching lines @@
     get_file_info_callbacks_.front().Run(entry, false);
     get_file_info_callbacks_.pop();
   }
 
   void OnGetFileInfoError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     get_file_info_callbacks_.front().Run(MtpFileEntry(), true);
     get_file_info_callbacks_.pop();
   }
 
+  void FinishSetupOnOriginThread(dbus::Bus* bus, bool service_has_owner) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    if (!service_has_owner) {
+#if !defined(OS_CHROMEOS)
+      // |session_bus_| will not get used. Manually shut it down.
+      session_bus_->PostTaskToDBusThread(
+          FROM_HERE, base::Bind(&dbus::Bus::ShutdownAndBlock, session_bus_));
+#endif
+      return;
+    }
+
+    mtp_client_.reset(
+        MediaTransferProtocolDaemonClient::Create(bus, false /* not stub */));
+
+    // Set up signals and start initializing |storage_info_map_|.
+    mtp_client_->SetUpConnections(
+        base::Bind(&MediaTransferProtocolManagerImpl::OnStorageChanged,
+                   weak_ptr_factory_.GetWeakPtr()));
+    mtp_client_->EnumerateStorages(
+        base::Bind(&MediaTransferProtocolManagerImpl::OnEnumerateStorages,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&base::DoNothing));
+  }
+
   // Mtpd DBus client.
   scoped_ptr<MediaTransferProtocolDaemonClient> mtp_client_;
 
 #if !defined(OS_CHROMEOS)
   // And a D-Bus session for talking to mtpd.
   scoped_refptr<dbus::Bus> session_bus_;
 #endif
 
   // Device attachment / detachment observers.
   ObserverList<Observer> observers_;
@@ skipping 28 matching lines @@
   DCHECK(!g_media_transfer_protocol_manager);
 
   g_media_transfer_protocol_manager =
       new MediaTransferProtocolManagerImpl(task_runner);
   VLOG(1) << "MediaTransferProtocolManager initialized";
 
   return g_media_transfer_protocol_manager;
 }
 
 }  // namespace device