Implement CopyFileFromLocal of MTPDeviceAsyncDelegate.

chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEDIA_GALLERIES_LINUX_MTP_DEVICE_DELEGATE_IMPL_LINUX_H_
 #define CHROME_BROWSER_MEDIA_GALLERIES_LINUX_MTP_DEVICE_DELEGATE_IMPL_LINUX_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 14 matching lines @@
 // MTPDeviceDelegateImplLinux communicates with the media transfer protocol
 // (MTP) device to complete file system operations. These operations are
 // performed asynchronously. Instantiate this class per MTP device storage.
 // MTPDeviceDelegateImplLinux lives on the IO thread.
 // MTPDeviceDelegateImplLinux does a call-and-reply to the UI thread
 // to dispatch the requests to MediaTransferProtocolManager.
 class MTPDeviceDelegateImplLinux : public MTPDeviceAsyncDelegate {
  private:
   friend void CreateMTPDeviceAsyncDelegate(
       const std::string&,
+      const bool read_only,
       const CreateMTPDeviceAsyncDelegateCallback&);
 
   enum InitializationState {
     UNINITIALIZED = 0,
     PENDING_INIT,
     INITIALIZED
   };
 
   // Used to represent pending task details.
   struct PendingTaskInfo {
@@ skipping 14 matching lines @@
 
   // Maps file ids to file nodes.
   typedef std::map<uint32, MTPFileNode*> FileIdToMTPFileNodeMap;
 
   // Maps file paths to file info.
   typedef std::map<base::FilePath, storage::DirectoryEntry> FileInfoCache;
 
   // Should only be called by CreateMTPDeviceAsyncDelegate() factory call.
   // Defer the device initializations until the first file operation request.
   // Do all the initializations in EnsureInitAndRunTask() function.
-  explicit MTPDeviceDelegateImplLinux(const std::string& device_location);
+  MTPDeviceDelegateImplLinux(const std::string& device_location,
+                             const bool read_only);
 
   // Destructed via CancelPendingTasksAndDeleteDelegate().
   ~MTPDeviceDelegateImplLinux() override;
 
   // MTPDeviceAsyncDelegate:
   void GetFileInfo(const base::FilePath& file_path,
                    const GetFileInfoSuccessCallback& success_callback,
                    const ErrorCallback& error_callback) override;
   void ReadDirectory(const base::FilePath& root,
                      const ReadDirectorySuccessCallback& success_callback,
                      const ErrorCallback& error_callback) override;
   void CreateSnapshotFile(
       const base::FilePath& device_file_path,
       const base::FilePath& local_path,
       const CreateSnapshotFileSuccessCallback& success_callback,
       const ErrorCallback& error_callback) override;
   bool IsStreaming() override;
   void ReadBytes(const base::FilePath& device_file_path,
                  const scoped_refptr<net::IOBuffer>& buf,
                  int64 offset,
                  int buf_len,
                  const ReadBytesSuccessCallback& success_callback,
                  const ErrorCallback& error_callback) override;
+  bool IsReadOnly() override;
+  void CopyFileFromLocal(
+      const base::FilePath& source_file_path,
+      const base::FilePath& device_file_path,
+      const CopyFileFromLocalSuccessCallback& success_callback,
+      const ErrorCallback& error_callback) override;
   void CancelPendingTasksAndDeleteDelegate() override;
 
   // The internal methods correspond to the similarly named methods above.
   // The |root_node_| cache should be filled at this point.
   virtual void GetFileInfoInternal(
       const base::FilePath& file_path,
       const GetFileInfoSuccessCallback& success_callback,
       const ErrorCallback& error_callback);
   virtual void ReadDirectoryInternal(
       const base::FilePath& root,
       const ReadDirectorySuccessCallback& success_callback,
       const ErrorCallback& error_callback);
   virtual void CreateSnapshotFileInternal(
       const base::FilePath& device_file_path,
       const base::FilePath& local_path,
       const CreateSnapshotFileSuccessCallback& success_callback,
       const ErrorCallback& error_callback);
   virtual void ReadBytesInternal(
       const base::FilePath& device_file_path,
       net::IOBuffer* buf, int64 offset, int buf_len,
       const ReadBytesSuccessCallback& success_callback,
       const ErrorCallback& error_callback);
+  virtual void CopyFileFromLocalInternal(
+      const base::FilePath& device_file_path,
+      const CopyFileFromLocalSuccessCallback& success_callback,
+      const ErrorCallback& error_callback,
+      const int source_file_descriptor);
 
   // Ensures the device is initialized for communication.
   // If the device is already initialized, call RunTask().
   //
   // If the device is uninitialized, store the |task_info| in a pending task
   // queue and runs the pending tasks in the queue once the device is
   // successfully initialized.
   void EnsureInitAndRunTask(const PendingTaskInfo& task_info);
 
   // Runs a task. If |task_info.path| is empty, or if the path is cached, runs
@@ skipping 90 matching lines @@
                       const base::File::Info& file_info, int bytes_read);
 
   // Called when FillFileCache() succeeds.
   void OnDidFillFileCache(const base::FilePath& path,
                           const storage::AsyncFileUtil::EntryList& file_list,
                           bool has_more);
 
   // Called when FillFileCache() fails.
   void OnFillFileCacheFailed(base::File::Error error);
 
+  // Called when CopyFileFromLocal() succeeds.
+  void OnDidCopyFileFromLocal(
+      const CopyFileFromLocalSuccessCallback& success_callback,
+      const int source_file_descriptor);
+
+  // Called when CopyFileFromLocal() fails.
+  void HandleCopyFileFromLocalError(const ErrorCallback& error_callback,
+                                    const int source_file_descriptor,
+                                    base::File::Error error);
+
   // Handles the device file |error| while operating on |file_id|.
   // |error_callback| is invoked to notify the caller about the file error.
   void HandleDeviceFileError(const ErrorCallback& error_callback,
                              uint32 file_id,
                              base::File::Error error);
 
   // Given a full path, returns a non-empty sub-path that needs to be read into
   // the cache if such a uncached path exists.
   // |cached_path| is the portion of |path| that has had cache lookup attempts.
   base::FilePath NextUncachedPathComponent(
@@ skipping 15 matching lines @@
   // overload the device.
   bool task_in_progress_;
 
   // Registered file system device path. This path does not
   // correspond to a real device path (e.g. "/usb:2,2:81282").
   const base::FilePath device_path_;
 
   // MTP device storage name (e.g. "usb:2,2:81282").
   std::string storage_name_;
 
+  // Mode for opening storage.
+  const bool read_only_;
+
   // A list of pending tasks that needs to be run when the device is
   // initialized or when the current task in progress is complete.
   std::deque<PendingTaskInfo> pending_tasks_;
 
   // Used to track the current snapshot file request. A snapshot file is created
   // incrementally. CreateSnapshotFile request reads the device file and writes
   // to the snapshot file in chunks. In order to retain the order of the
   // snapshot file requests, make sure there is only one active snapshot file
   // request at any time.
   scoped_ptr<SnapshotRequestInfo> current_snapshot_request_info_;
@@ skipping 16 matching lines @@
   // the ReadDirectory operation.
   FileInfoCache file_info_cache_;
 
   // For callbacks that may run after destruction.
   base::WeakPtrFactory<MTPDeviceDelegateImplLinux> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MTPDeviceDelegateImplLinux);
 };
 
 #endif  // CHROME_BROWSER_MEDIA_GALLERIES_LINUX_MTP_DEVICE_DELEGATE_IMPL_LINUX_H_