Linux/CrOS: Retry connecting to 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>
@@ skipping 32 matching lines @@
     DCHECK(!task_runner.get());
 #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);
 #endif
 
-    dbus::Bus::GetServiceOwnerCallback reply_task =
+    mtpd_owner_changed_callback_ =
         base::Bind(&MediaTransferProtocolManagerImpl::FinishSetupOnOriginThread,
                    weak_ptr_factory_.GetWeakPtr());
-    GetBus()->GetServiceOwner(mtpd::kMtpdServiceName, reply_task);
+    GetBus()->ListenForServiceOwnerChange(mtpd::kMtpdServiceName,
+                                          mtpd_owner_changed_callback_);
+    GetBus()->GetServiceOwner(mtpd::kMtpdServiceName,
+                              mtpd_owner_changed_callback_);

[satorux1, 2013/06/03 02:26:06]

You might want to add a comment why we are doing this, as it's not very obvious.

[Lei Zhang, 2013/06/04 00:35:53]

Done.

   }
 
   virtual ~MediaTransferProtocolManagerImpl() {
     DCHECK(g_media_transfer_protocol_manager);
     g_media_transfer_protocol_manager = NULL;
+    GetBus()->UnlistenForServiceOwnerChange(mtpd::kMtpdServiceName,
+                                            mtpd_owner_changed_callback_);
     VLOG(1) << "MediaTransferProtocolManager Shutdown completed";
   }
 
   // MediaTransferProtocolManager override.
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   // MediaTransferProtocolManager override.
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
@@ skipping 18 matching lines @@
     DCHECK(thread_checker_.CalledOnValidThread());
     StorageInfoMap::const_iterator it = storage_info_map_.find(storage_name);
     return it != storage_info_map_.end() ? &it->second : NULL;
   }
 
   // MediaTransferProtocolManager override.
   virtual void OpenStorage(const std::string& storage_name,
                            const std::string& mode,
                            const OpenStorageCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(storage_info_map_, storage_name)) {
+    if (!ContainsKey(storage_info_map_, storage_name) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     open_storage_callbacks_.push(callback);
     mtp_client_->OpenStorage(
         storage_name,
         mode,
         base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnOpenStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void CloseStorage(const std::string& storage_handle,
                             const CloseStorageCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true);
       return;
     }
     close_storage_callbacks_.push(std::make_pair(callback, storage_handle));
     mtp_client_->CloseStorage(
         storage_handle,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadDirectoryByPath(
       const std::string& storage_handle,
       const std::string& path,
       const ReadDirectoryCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(), true);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryByPath(
         storage_handle,
         path,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadDirectoryById(
       const std::string& storage_handle,
       uint32 file_id,
       const ReadDirectoryCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(), true);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryById(
         storage_handle,
         file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadFileChunkByPath(const std::string& storage_handle,
                                    const std::string& path,
                                    uint32 offset,
                                    uint32 count,
                                    const ReadFileCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     read_file_callbacks_.push(callback);
     mtp_client_->ReadFileChunkByPath(
         storage_handle, path, offset, count,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadFileChunkById(const std::string& storage_handle,
                                  uint32 file_id,
                                  uint32 offset,
                                  uint32 count,
                                  const ReadFileCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::string(), true);
       return;
     }
     read_file_callbacks_.push(callback);
     mtp_client_->ReadFileChunkById(
         storage_handle, file_id, offset, count,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void GetFileInfoByPath(const std::string& storage_handle,
                                  const std::string& path,
                                  const GetFileInfoCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(MtpFileEntry(), true);
       return;
     }
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfoByPath(
         storage_handle,
         path,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void GetFileInfoById(const std::string& storage_handle,
                                uint32 file_id,
                                const GetFileInfoCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
-    if (!ContainsKey(handles_, storage_handle)) {
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(MtpFileEntry(), true);
       return;
     }
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfoById(
         storage_handle,
         file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
   // Map of storage names to storage info.
   typedef std::map<std::string, MtpStorageInfo> StorageInfoMap;
   // Callback queues - DBus communication is in-order, thus callbacks are
   // received in the same order as the requests.
   typedef std::queue<OpenStorageCallback> OpenStorageCallbackQueue;
   // (callback, handle)
   typedef std::queue<std::pair<CloseStorageCallback, std::string>
                     > CloseStorageCallbackQueue;
   typedef std::queue<ReadDirectoryCallback> ReadDirectoryCallbackQueue;
   typedef std::queue<ReadFileCallback> ReadFileCallbackQueue;
   typedef std::queue<GetFileInfoCallback> GetFileInfoCallbackQueue;
 
   void OnStorageChanged(bool is_attach, const std::string& storage_name) {
     DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK(mtp_client_);
     if (is_attach) {
       mtp_client_->GetStorageInfo(
           storage_name,
           base::Bind(&MediaTransferProtocolManagerImpl::OnGetStorageInfo,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&base::DoNothing));
       return;
     }
 
     // Detach case.
     StorageInfoMap::iterator it = storage_info_map_.find(storage_name);
     if (it == storage_info_map_.end()) {
       // This might happen during initialization when |storage_info_map_| has
       // not been fully populated yet?
       return;
     }
     storage_info_map_.erase(it);
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       StorageChanged(false /* detach */, storage_name));
   }
 
   void OnEnumerateStorages(const std::vector<std::string>& storage_names) {
     DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK(mtp_client_);
     for (size_t i = 0; i < storage_names.size(); ++i) {
       mtp_client_->GetStorageInfo(
           storage_names[i],
           base::Bind(&MediaTransferProtocolManagerImpl::OnGetStorageInfo,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&base::DoNothing));
     }
   }
 
   void OnGetStorageInfo(const MtpStorageInfo& storage_info) {
@@ skipping 93 matching lines @@
   dbus::Bus* GetBus() {
     DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_CHROMEOS)
     return chromeos::DBusThreadManager::Get()->GetSystemBus();
 #else
     return session_bus_.get();
 #endif
   }
 
   // Callback to finish initialization after figuring out if the mtp service
-  // has an owner.
-  // |service_owner| contains the name of the current owner, if any.
-  void FinishSetupOnOriginThread(const std::string& service_owner) {
+  // has an owner, or if the service owner has changed.
+  // |mtpd_service_owner| contains the name of the current owner, if any.
+  void FinishSetupOnOriginThread(const std::string& mtpd_service_owner) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
-    if (service_owner.empty()) {
-#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
+    if (mtpd_service_owner == current_mtpd_owner_)
+      return;
+
+    if (mtpd_service_owner.empty()) {
+      current_mtpd_owner_.clear();
+      mtp_client_.reset();
       return;
     }
 
+    current_mtpd_owner_ = mtpd_service_owner;
+
     mtp_client_.reset(
         MediaTransferProtocolDaemonClient::Create(GetBus(),
                                                   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,
@@ skipping 15 matching lines @@
   base::WeakPtrFactory<MediaTransferProtocolManagerImpl> weak_ptr_factory_;
 
   // Everything below is only accessed on the UI thread.
 
   // Map to keep track of attached storages by name.
   StorageInfoMap storage_info_map_;
 
   // Set of open storage handles.
   std::set<std::string> handles_;
 
+  dbus::Bus::GetServiceOwnerCallback mtpd_owner_changed_callback_;
+
+  std::string current_mtpd_owner_;
+
   // Queued callbacks.
   OpenStorageCallbackQueue open_storage_callbacks_;
   CloseStorageCallbackQueue close_storage_callbacks_;
   ReadDirectoryCallbackQueue read_directory_callbacks_;
   ReadFileCallbackQueue read_file_callbacks_;
   GetFileInfoCallbackQueue get_file_info_callbacks_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaTransferProtocolManagerImpl);
 };
 
 }  // namespace
 
 // static
 MediaTransferProtocolManager* MediaTransferProtocolManager::Initialize(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   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