Implement MoveFileLocal (with rename operation).

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 <algorithm>
 #include <map>
 #include <queue>
 #include <set>
@@ skipping 205 matching lines @@
         storage_handle,
         file_ids,
         kInitialOffset,
         file_ids.size(),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
+  void RenameObject(const std::string& storage_handle,
+                    const uint32 object_id,
+                    const std::string& new_name,
+                    const RenameObjectCallback& callback) override {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+      callback.Run(true /* error */);
+      return;
+    }
+    rename_object_callbacks_.push(callback);
+    mtp_client_->RenameObject(
+        storage_handle, object_id, new_name,
+        base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObject,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&MediaTransferProtocolManagerImpl::OnRenameObjectError,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
   void CopyFileFromLocal(const std::string& storage_handle,
                          const int source_file_descriptor,
                          const uint32 parent_id,
                          const std::string& file_name,
                          const CopyFileFromLocalCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(true /* error */);
       return;
     }
@@ skipping 28 matching lines @@
   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;
+  typedef std::queue<RenameObjectCallback> RenameObjectCallbackQueue;
   typedef std::queue<CopyFileFromLocalCallback> CopyFileFromLocalCallbackQueue;
   typedef std::queue<DeleteObjectCallback> DeleteObjectCallbackQueue;
 
   void OnStorageAttached(const std::string& storage_name) {
     DCHECK(thread_checker_.CalledOnValidThread());
     mtp_client_->GetStorageInfo(
         storage_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetStorageInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&base::DoNothing));
@@ skipping 196 matching lines @@
       OnGetFileInfoError();
     }
   }
 
   void OnGetFileInfoError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     get_file_info_callbacks_.front().Run(MtpFileEntry(), true);
     get_file_info_callbacks_.pop();
   }
 
+  void OnRenameObject() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    rename_object_callbacks_.front().Run(false /* no error */);
+    rename_object_callbacks_.pop();
+  }
+
+  void OnRenameObjectError() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    rename_object_callbacks_.front().Run(true /* error */);
+    rename_object_callbacks_.pop();
+  }
+
   void OnCopyFileFromLocal() {
     DCHECK(thread_checker_.CalledOnValidThread());
     copy_file_from_local_callbacks_.front().Run(false /* no error */);
     copy_file_from_local_callbacks_.pop();
   }
 
   void OnCopyFileFromLocalError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     copy_file_from_local_callbacks_.front().Run(true /* error */);
     copy_file_from_local_callbacks_.pop();
@@ skipping 85 matching lines @@
   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_;
+  RenameObjectCallbackQueue rename_object_callbacks_;
   CopyFileFromLocalCallbackQueue copy_file_from_local_callbacks_;
   DeleteObjectCallbackQueue delete_object_callbacks_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<MediaTransferProtocolManagerImpl> weak_ptr_factory_;
 
   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