Implement CopyFileFromLocal of MTPDeviceAsyncDelegate.

chrome/browser/media_galleries/fileapi/device_media_async_file_util.cc

 // Copyright (c) 2013 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/fileapi/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 61 matching lines @@
 
 // Called when ReadDirectory method call failed to enumerate the directory
 // objects. |callback| is invoked to notify the caller about the |error|
 // that occured while reading the directory objects.
 void OnReadDirectoryError(const AsyncFileUtil::ReadDirectoryCallback& callback,
                           base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(error, AsyncFileUtil::EntryList(), false /*no more*/);
 }
 
+// Called when CopyInForeignFile method call failed.
+void OnCopyInForeignFileError(const AsyncFileUtil::StatusCallback& callback,
+                              base::File::Error error) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  callback.Run(error);
+}
+
 // Called on a blocking pool thread to create a snapshot file to hold the
 // contents of |device_file_path|. The snapshot file is created in the
 // "profile_path/kDeviceMediaAsyncFileUtilTempDir" directory. Return the
 // snapshot file path or an empty path on failure.
 base::FilePath CreateSnapshotFileOnBlockingPool(
     const base::FilePath& device_file_path,
     const base::FilePath& profile_path) {
   base::FilePath snapshot_file_path;
   base::FilePath media_file_system_dir_path =
       profile_path.AppendASCII(kDeviceMediaAsyncFileUtilTempDir);
@@ skipping 231 matching lines @@
 void DeviceMediaAsyncFileUtil::ReadDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
     OnReadDirectoryError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
+
   delegate->ReadDirectory(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidReadDirectory,
                  weak_ptr_factory_.GetWeakPtr(),
                  make_scoped_refptr(context->task_runner()),
                  callback),
       base::Bind(&OnReadDirectoryError, callback));
 }
 
 void DeviceMediaAsyncFileUtil::Touch(
@@ skipping 39 matching lines @@
   NOTIMPLEMENTED();
   callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void DeviceMediaAsyncFileUtil::CopyInForeignFile(
     scoped_ptr<FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  NOTIMPLEMENTED();
-  callback.Run(base::File::FILE_ERROR_SECURITY);
+
+  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(dest_url);
+  if (!delegate) {
+    OnCopyInForeignFileError(callback, base::File::FILE_ERROR_NOT_FOUND);
+    return;
+  }
+  if (delegate->IsReadOnly()) {
+    OnCopyInForeignFileError(callback, base::File::FILE_ERROR_SECURITY);
+    return;
+  }
+
+  delegate->CopyFileFromLocal(
+      src_file_path, dest_url.path(),
+      base::Bind(&DeviceMediaAsyncFileUtil::OnDidCopyInForeignFile,
+                 weak_ptr_factory_.GetWeakPtr(), callback),
+      base::Bind(&OnCopyInForeignFileError, callback));
 }
 
 void DeviceMediaAsyncFileUtil::DeleteFile(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   NOTIMPLEMENTED();
   callback.Run(base::File::FILE_ERROR_SECURITY);
 }
@@ skipping 100 matching lines @@
 
   base::PostTaskAndReplyWithResult(
       task_runner,
       FROM_HERE,
       base::Bind(&MediaPathFilterWrapper::FilterMediaEntries,
                  media_path_filter_wrapper_,
                  file_list),
       base::Bind(&OnDidCheckMediaForReadDirectory, callback, has_more));
 }
 
+void DeviceMediaAsyncFileUtil::OnDidCopyInForeignFile(
+    const StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+  callback.Run(base::File::FILE_OK);
+}
+
 bool DeviceMediaAsyncFileUtil::validate_media_files() const {
   return media_path_filter_wrapper_.get() != NULL;
 }