Implement MoveFileLocal (with rename operation).

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.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 "chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h"
 
 #include <fcntl.h>
 #include <algorithm>
 #include <vector>
 
@@ skipping 171 matching lines @@
     const bool read_only,
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
       GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->ReadBytes(request);
 }
 
+// Renames |object_id| to |new_name|.
+//
+// |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
+// |object_id| is an id of object to be renamed.
+// |new_name| is new name of the object.
+// |success_callback| is called when the object is renamed successfully.
+// |error_callback| is called when it fails to rename the object.
+// |success_callback| and |error_callback| runs on the IO thread.
+void RenameObjectOnUIThread(
+    const std::string& storage_name,
+    const bool read_only,
+    const uint32 object_id,
+    const std::string& new_name,
+    const MTPDeviceTaskHelper::RenameObjectSuccessCallback& success_callback,
+    const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  MTPDeviceTaskHelper* task_helper =
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
+  if (!task_helper)
+    return;
+  task_helper->RenameObject(object_id, new_name, success_callback,
+                            error_callback);
+}
+
 // Copies the file |source_file_descriptor| to |file_name| in |parent_id|.
 //
 // |storage_name| specifies the name of the storage device.
 // |read_only| specifies the mode of the storage device.
 // |source_file_descriptor| file descriptor of source file.
 // |parent_id| object id of a target directory.
 // |file_name| file name of a target file.
 // |success_callback| is called when the file is copied successfully.
 // |error_callback| is called when it fails to copy file.
 // Since this method does not close the file descriptor, callbacks are
@@ skipping 613 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (source_file_info.is_directory) {
     error_callback.Run(base::File::FILE_ERROR_NOT_A_FILE);
     PendingRequestDone();
     return;
   }
 
   if (source_file_path.DirName() == device_file_path.DirName()) {
     // If a file is moved in a same directory, rename the file.
-    // TODO(yawano) Implement rename operation.
-    error_callback.Run(base::File::FILE_ERROR_SECURITY);
+    uint32 file_id;
+    if (CachedPathToId(source_file_path, &file_id)) {
+      const MTPDeviceTaskHelper::RenameObjectSuccessCallback
+          success_callback_wrapper = base::Bind(
+              &MTPDeviceDelegateImplLinux::OnDidMoveFileLocalWithRename,
+              weak_ptr_factory_.GetWeakPtr(), success_callback, file_id);
+      const MTPDeviceTaskHelper::ErrorCallback error_callback_wrapper =
+          base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
+                     weak_ptr_factory_.GetWeakPtr(), error_callback, file_id);
+      const base::Closure closure =
+          base::Bind(&RenameObjectOnUIThread, storage_name_, read_only_,
+                     file_id, device_file_path.BaseName().value(),
+                     success_callback_wrapper, error_callback_wrapper);
+      EnsureInitAndRunTask(PendingTaskInfo(
+          base::FilePath(), content::BrowserThread::UI, FROM_HERE, closure));
+    } else {
+      error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
+    }
   } else {
     // If a file is moved to a different directory, create a copy to the
     // destination path, and remove source file.
     const CopyFileLocalSuccessCallback& success_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::DeleteFileInternal,
                    weak_ptr_factory_.GetWeakPtr(), source_file_path,
                    success_callback, error_callback, source_file_info);
     CopyFileLocal(source_file_path, device_file_path,
                   create_temporary_file_callback,
                   base::Bind(&FakeCopyFileProgressCallback),
@@ skipping 470 matching lines @@
 
 void MTPDeviceDelegateImplLinux::OnDidCopyFileFromLocalOfCopyFileLocal(
     const CopyFileFromLocalSuccessCallback success_callback,
     const base::FilePath& temporary_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   DeleteTemporaryFile(temporary_file_path);
   success_callback.Run();
 }
 
+void MTPDeviceDelegateImplLinux::OnDidMoveFileLocalWithRename(
+    const MoveFileLocalSuccessCallback& success_callback,
+    const uint32 file_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  EvictCachedPathToId(file_id);
+  success_callback.Run();
+  PendingRequestDone();
+}
+
 void MTPDeviceDelegateImplLinux::OnDidCopyFileFromLocal(
     const CopyFileFromLocalSuccessCallback& success_callback,
     const int source_file_descriptor) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   const base::Closure closure = base::Bind(&CloseFileDescriptor,
                                            source_file_descriptor);
 
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
                                    closure);
@@ skipping 139 matching lines @@
   }
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const bool read_only,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(new MTPDeviceDelegateImplLinux(device_location, read_only));
 }