Implement CopyFileFromLocal of MTPDeviceAsyncDelegate.

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>
 
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper.h"
 #include "chrome/browser/media_galleries/linux/mtp_device_task_helper_map_service.h"
 #include "chrome/browser/media_galleries/linux/snapshot_file_details.h"
 #include "net/base/io_buffer.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
@@ skipping 22 matching lines @@
       result = relative_path.value();
     }
   }
   return result;
 }
 
 // Returns the MTPDeviceTaskHelper object associated with the MTP device
 // storage.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // Returns NULL if the |storage_name| is no longer valid (e.g. because the
 // corresponding storage device is detached, etc).
 MTPDeviceTaskHelper* GetDeviceTaskHelperForStorage(
-    const std::string& storage_name) {
+    const std::string& storage_name,
+    const bool read_only) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return MTPDeviceTaskHelperMapService::GetInstance()->GetDeviceTaskHelper(
-      storage_name);
+      storage_name,
+      read_only);
 }
 
 // Opens the storage device for communication.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // |reply_callback| is called when the OpenStorage request completes.
 // |reply_callback| runs on the IO thread.
 void OpenStorageOnUIThread(
     const std::string& storage_name,
+    const bool read_only,
     const MTPDeviceTaskHelper::OpenStorageCallback& reply_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper) {
     task_helper =
         MTPDeviceTaskHelperMapService::GetInstance()->CreateDeviceTaskHelper(
-            storage_name);
+            storage_name, read_only);
   }
-  task_helper->OpenStorage(storage_name, reply_callback);
+  task_helper->OpenStorage(storage_name, read_only, reply_callback);
 }
 
 // Enumerates the |dir_id| directory file entries.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // |success_callback| is called when the ReadDirectory request succeeds.
 // |error_callback| is called when the ReadDirectory request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void ReadDirectoryOnUIThread(
     const std::string& storage_name,
+    const bool read_only,
     uint32 dir_id,
     const MTPDeviceTaskHelper::ReadDirectorySuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->ReadDirectory(dir_id, success_callback, error_callback);
 }
 
 // Gets the |file_path| details.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // |success_callback| is called when the GetFileInfo request succeeds.
 // |error_callback| is called when the GetFileInfo request fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void GetFileInfoOnUIThread(
     const std::string& storage_name,
+    const bool read_only,
     uint32 file_id,
     const MTPDeviceTaskHelper::GetFileInfoSuccessCallback& success_callback,
     const MTPDeviceTaskHelper::ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->GetFileInfo(file_id, success_callback, error_callback);
 }
 
 // Copies the contents of |device_file_path| to |snapshot_file_path|.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // |device_file_path| specifies the media device file path.
 // |snapshot_file_path| specifies the platform path of the snapshot file.
 // |file_size| specifies the number of bytes that will be written to the
 // snapshot file.
 // |success_callback| is called when the copy operation succeeds.
 // |error_callback| is called when the copy operation fails.
 // |success_callback| and |error_callback| runs on the IO thread.
 void WriteDataIntoSnapshotFileOnUIThread(
     const std::string& storage_name,
+    const bool read_only,
     const SnapshotRequestInfo& request_info,
     const base::File::Info& snapshot_file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->WriteDataIntoSnapshotFile(request_info, snapshot_file_info);
 }
 
 // Copies the contents of |device_file_path| to |snapshot_file_path|.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 //
 // |storage_name| specifies the name of the storage device.
+// |read_only| specifies the mode of the storage device.
 // |request| is a struct containing details about the byte read request.
 void ReadBytesOnUIThread(
     const std::string& storage_name,
+    const bool read_only,
     const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->ReadBytes(request);
 }
 
+// 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
+// responsible for closing it.
+void CopyFileFromLocalOnUIThread(
+    const std::string& storage_name,
+    const bool read_only,
+    const int source_file_descriptor,
+    const uint32 parent_id,
+    const std::string& file_name,
+    const MTPDeviceTaskHelper::CopyFileFromLocalSuccessCallback&
+        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->CopyFileFromLocal(storage_name, source_file_descriptor,
+                                 parent_id, file_name, success_callback,
+                                 error_callback);
+}
+
 // Closes the device storage specified by the |storage_name| and destroys the
 // MTPDeviceTaskHelper object associated with the device storage.
 //
 // Called on the UI thread to dispatch the request to the
 // MediaTransferProtocolManager.
 void CloseStorageAndDestroyTaskHelperOnUIThread(
-    const std::string& storage_name) {
+    const std::string& storage_name,
+    const bool read_only) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   MTPDeviceTaskHelper* task_helper =
-      GetDeviceTaskHelperForStorage(storage_name);
+      GetDeviceTaskHelperForStorage(storage_name, read_only);
   if (!task_helper)
     return;
   task_helper->CloseStorage();
   MTPDeviceTaskHelperMapService::GetInstance()->DestroyDeviceTaskHelper(
-      storage_name);
+      storage_name, read_only);
+}
+
+// Closes |file_descriptor| on file thread.
+void CloseFileDescriptor(const int file_descriptor) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+
+  IGNORE_EINTR(close(file_descriptor));
 }
 
 }  // namespace
 
 MTPDeviceDelegateImplLinux::PendingTaskInfo::PendingTaskInfo(
     const base::FilePath& path,
     content::BrowserThread::ID thread_id,
     const tracked_objects::Location& location,
     const base::Closure& task)
     : path(path),
@@ skipping 106 matching lines @@
        it != children_.end(); ++it) {
     if (it->second->file_id() == file_id) {
       children_.erase(it);
       return true;
     }
   }
   return false;
 }
 
 MTPDeviceDelegateImplLinux::MTPDeviceDelegateImplLinux(
-    const std::string& device_location)
+    const std::string& device_location,
+    const bool read_only)
     : init_state_(UNINITIALIZED),
       task_in_progress_(false),
       device_path_(device_location),
+      read_only_(read_only),
       root_node_(new MTPFileNode(mtpd::kRootFileId,
                                  "",    // Root node has no name.
                                  NULL,  // And no parent node.
                                  &file_id_to_node_map_)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!device_path_.empty());
   base::RemoveChars(device_location, kRootPath, &storage_name_);
   DCHECK(!storage_name_.empty());
 }
@@ skipping 98 matching lines @@
                  offset,
                  buf_len,
                  success_callback,
                  error_callback);
   EnsureInitAndRunTask(PendingTaskInfo(device_file_path,
                                        content::BrowserThread::IO,
                                        FROM_HERE,
                                        closure));
 }
 
+bool MTPDeviceDelegateImplLinux::IsReadOnly() {
+  return read_only_;
+}
+
+void MTPDeviceDelegateImplLinux::CopyFileFromLocal(
+    const base::FilePath& source_file_path,
+    const base::FilePath& device_file_path,
+    const CopyFileFromLocalSuccessCallback& success_callback,
+    const ErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(!source_file_path.empty());
+  DCHECK(!device_file_path.empty());
+  base::Closure closure =
+      base::Bind(&MTPDeviceDelegateImplLinux::CopyFileFromLocalInternal,
+                 weak_ptr_factory_.GetWeakPtr(), source_file_path,
+                 device_file_path, success_callback, error_callback);
+  EnsureInitAndRunTask(PendingTaskInfo(device_file_path.DirName(),
+                                       content::BrowserThread::FILE, FROM_HERE,
+                                       closure));
+}
+
 void MTPDeviceDelegateImplLinux::CancelPendingTasksAndDeleteDelegate() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // To cancel all the pending tasks, destroy the MTPDeviceTaskHelper object.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&CloseStorageAndDestroyTaskHelperOnUIThread, storage_name_));
+      base::Bind(&CloseStorageAndDestroyTaskHelperOnUIThread,
+                 storage_name_,
+                 read_only_));
   delete this;
 }
 
 void MTPDeviceDelegateImplLinux::GetFileInfoInternal(
     const base::FilePath& file_path,
     const GetFileInfoSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   uint32 file_id;
   if (CachedPathToId(file_path, &file_id)) {
     GetFileInfoSuccessCallback success_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr(),
                    success_callback);
     ErrorCallback error_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    file_id);
 
 
     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
                                        storage_name_,
+                                       read_only_,
                                        file_id,
                                        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);
   }
@@ skipping 14 matching lines @@
                    dir_id,
                    success_callback,
                    error_callback);
     ErrorCallback error_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    dir_id);
     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
                                        storage_name_,
+                                       read_only_,
                                        dir_id,
                                        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);
   }
@@ skipping 19 matching lines @@
             &MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile,
             weak_ptr_factory_.GetWeakPtr(),
             base::Passed(&request_info));
     ErrorCallback error_callback_wrapper =
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    file_id);
     base::Closure closure = base::Bind(&GetFileInfoOnUIThread,
                                        storage_name_,
+                                       read_only_,
                                        file_id,
                                        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);
   }
@@ skipping 13 matching lines @@
         file_id, buf, offset, buf_len,
         base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadBytes,
                    weak_ptr_factory_.GetWeakPtr(),
                    success_callback),
         base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                    weak_ptr_factory_.GetWeakPtr(),
                    error_callback,
                    file_id));
 
     base::Closure closure =
-        base::Bind(base::Bind(&ReadBytesOnUIThread, storage_name_, request));
+        base::Bind(&ReadBytesOnUIThread, storage_name_, read_only_, request);
     EnsureInitAndRunTask(PendingTaskInfo(base::FilePath(),
                                          content::BrowserThread::UI,
                                          FROM_HERE,
                                          closure));
   } else {
     error_callback.Run(base::File::FILE_ERROR_NOT_FOUND);
   }
   PendingRequestDone();
 }
 
+void MTPDeviceDelegateImplLinux::CopyFileFromLocalInternal(
+    const base::FilePath& source_file_path,
+    const base::FilePath& device_file_path,
+    const CopyFileFromLocalSuccessCallback& success_callback,
+    const ErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+
+  const int source_file_descriptor =
+      open(source_file_path.value().c_str(), O_RDONLY);
+
+  if (source_file_descriptor >= 0) {
+    const base::Closure closure = base::Bind(
+        &MTPDeviceDelegateImplLinux::OnDidOpenFileDescriptorToCopyFileFromLocal,
+        weak_ptr_factory_.GetWeakPtr(), source_file_descriptor,
+        device_file_path, success_callback, error_callback);
+    EnsureInitAndRunTask(PendingTaskInfo(

[Lei Zhang, 2015/03/03 19:17:31]

Sorry I didn't point this out earlier, but this is also on the wrong thread.
It's probably easier to do just the open() on the FILE thread, and then reply
back to CopyFileFromLocalInternal() on the IO thread.

I highly recommend running the code to make sure it actually works.

[yawano, 2015/03/04 02:29:07]

Done. Thank you, we could make the code much simpler!

+        base::FilePath(), content::BrowserThread::IO, FROM_HERE, closure));
+  } else {
+    const base::Closure closure =
+        base::Bind(error_callback, base::File::FILE_ERROR_INVALID_OPERATION);
+    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+                                     closure);
+  }
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&MTPDeviceDelegateImplLinux::PendingRequestDone,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void MTPDeviceDelegateImplLinux::OnDidOpenFileDescriptorToCopyFileFromLocal(
+    const int source_file_descriptor,
+    const base::FilePath& device_file_path,
+    const CopyFileFromLocalSuccessCallback& success_callback,
+    const ErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  uint32 parent_id;
+  if (CachedPathToId(device_file_path.DirName(), &parent_id)) {
+    CopyFileFromLocalSuccessCallback success_callback_wrapper =
+        base::Bind(&MTPDeviceDelegateImplLinux::OnDidCopyFileFromLocal,
+                   weak_ptr_factory_.GetWeakPtr(), success_callback,
+                   source_file_descriptor);
+
+    ErrorCallback error_callback_wrapper = base::Bind(
+        &MTPDeviceDelegateImplLinux::HandleCopyFileFromLocalError,
+        weak_ptr_factory_.GetWeakPtr(), error_callback, source_file_descriptor);
+
+    base::Closure closure = base::Bind(&CopyFileFromLocalOnUIThread,
+                                       storage_name_,
+                                       read_only_,
+                                       source_file_descriptor,
+                                       parent_id,
+                                       device_file_path.BaseName().value(),
+                                       success_callback_wrapper,
+                                       error_callback_wrapper);
+
+    EnsureInitAndRunTask(PendingTaskInfo(
+        base::FilePath(), content::BrowserThread::UI, FROM_HERE, closure));
+  } else {
+    HandleCopyFileFromLocalError(error_callback, source_file_descriptor,
+                                 base::File::FILE_ERROR_INVALID_OPERATION);
+  }
+
+  PendingRequestDone();
+}
+
 void MTPDeviceDelegateImplLinux::EnsureInitAndRunTask(
     const PendingTaskInfo& task_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if ((init_state_ == INITIALIZED) && !task_in_progress_) {
     RunTask(task_info);
     return;
   }
 
   // Only *Internal functions have empty paths. Since they are the continuation
   // of the current running task, they get to cut in line.
   if (task_info.path.empty())
     pending_tasks_.push_front(task_info);
   else
     pending_tasks_.push_back(task_info);
 
   if (init_state_ == UNINITIALIZED) {
     init_state_ = PENDING_INIT;
     task_in_progress_ = true;
     content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&OpenStorageOnUIThread,
-                   storage_name_,
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&OpenStorageOnUIThread, storage_name_, read_only_,
                    base::Bind(&MTPDeviceDelegateImplLinux::OnInitCompleted,
                               weak_ptr_factory_.GetWeakPtr())));
   }
 }
 
 void MTPDeviceDelegateImplLinux::RunTask(const PendingTaskInfo& task_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK_EQ(INITIALIZED, init_state_);
   DCHECK(!task_in_progress_);
   task_in_progress_ = true;
@@ skipping 26 matching lines @@
       current_snapshot_request_info_->snapshot_file_path,
       base::Bind(
           &MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(
           &MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError,
           weak_ptr_factory_.GetWeakPtr()));
 
   base::Closure task_closure = base::Bind(&WriteDataIntoSnapshotFileOnUIThread,
                                           storage_name_,
+                                          read_only_,
                                           request_info,
                                           file_info);
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    task_closure);
 }
 
 void MTPDeviceDelegateImplLinux::PendingRequestDone() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(task_in_progress_);
   task_in_progress_ = false;
   ProcessNextPendingRequest();
 }
 
 void MTPDeviceDelegateImplLinux::ProcessNextPendingRequest() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!task_in_progress_);
   if (pending_tasks_.empty())
     return;
@@ skipping 26 matching lines @@
   DCHECK(task_in_progress_);
   if (!file_info.is_directory) {
     return HandleDeviceFileError(error_callback,
                                  dir_id,
                                  base::File::FILE_ERROR_NOT_A_DIRECTORY);
   }
 
   base::Closure task_closure =
       base::Bind(&ReadDirectoryOnUIThread,
                  storage_name_,
+                 read_only_,
                  dir_id,
                  base::Bind(&MTPDeviceDelegateImplLinux::OnDidReadDirectory,
                             weak_ptr_factory_.GetWeakPtr(),
                             dir_id,
                             success_callback),
                  base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                             weak_ptr_factory_.GetWeakPtr(),
                             error_callback,
                             dir_id));
   content::BrowserThread::PostTask(content::BrowserThread::UI,
@@ skipping 131 matching lines @@
 
 void MTPDeviceDelegateImplLinux::OnFillFileCacheFailed(
     base::File::Error /* error */) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // When filling the cache fails for the task at the front of the queue, clear
   // the path of the task so it will not try to do any more caching. Instead,
   // the task will just run and fail the CachedPathToId() lookup.
   pending_tasks_.front().path.clear();
 }
 
+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);
+
+  success_callback.Run();
+  PendingRequestDone();
+}
+
+void MTPDeviceDelegateImplLinux::HandleCopyFileFromLocalError(
+    const ErrorCallback& error_callback,
+    const int source_file_descriptor,
+    base::File::Error error) {
+  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);
+
+  error_callback.Run(error);
+  PendingRequestDone();
+}
+
 void MTPDeviceDelegateImplLinux::HandleDeviceFileError(
     const ErrorCallback& error_callback,
     uint32 file_id,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   FileIdToMTPFileNodeMap::iterator it = file_id_to_node_map_.find(file_id);
   if (it != file_id_to_node_map_.end()) {
     MTPFileNode* parent = it->second->parent();
     if (parent) {
@@ skipping 69 matching lines @@
     current_node = current_node->GetChild(device_relpath_components[i]);
     if (!current_node)
       return false;
   }
   *id = current_node->file_id();
   return true;
 }
 
 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));
+  callback.Run(new MTPDeviceDelegateImplLinux(device_location, read_only));
 }