Implement copy and move operations within the same remote file system.

chrome/browser/chromeos/gdata/gdata_file_system_proxy.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/chromeos/gdata/gdata_file_system_proxy.h"
 
+#include <vector>
+
 #include "base/bind.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using base::MessageLoopProxy;
 using content::BrowserThread;
 using fileapi::FileSystemOperationInterface;
 
 namespace {
 
 const char kGDataRootDirectory[] = "gdata";
 const char kFeedField[] = "feed";
 
 }  // namespace
 
 namespace gdata {
 
 base::FileUtilProxy::Entry GDataFileToFileUtilProxyEntry(
     const GDataFileBase& file) {
   base::FileUtilProxy::Entry entry;
   entry.is_directory = file.file_info().is_directory;
 
   // TODO(zelidrag): Add file name modification logic to enforce uniquness of
   // file paths across this file system.
   entry.name = file.file_name();

[zel, 2012/03/12 20:46:46]

aren't you supposed to append GDataFileBase::document_extension_ to hosted
documents here? 

[Ben Chan, 2012/03/13 00:29:21]

GDataFile::file_name_ should already include the document extension. This is
done in:

void GDataFile::UseOriginalFileName() {
  if (is_hosted_document_) {
    file_name_ = EscapeUtf8FileName(original_file_name_ + document_extension_);
  } else {
    ...
  }
}

 
   entry.size = file.file_info().size;
   entry.last_modified_time = file.file_info().last_modified;
   return entry;
 }
 
 // GetFileInfoDelegate is used to handle results of proxy's content search
 // during GetFileInfo call and route reply to the calling message loop.
 class GetFileInfoDelegate : public FindFileDelegateReplyBase {
  public:
@@ skipping 17 matching lines @@
                                 GDataDirectory* dir) OVERRIDE {
     DCHECK(dir);
     Reply(base::PLATFORM_FILE_OK, dir->file_info(), search_file_path_);
   }
 
   virtual void OnError(base::PlatformFileError error) OVERRIDE {
     Reply(error, base::PlatformFileInfo(), FilePath());
   }
 
  private:
-
   // Relays reply back to the callback on calling thread.
   void Reply(base::PlatformFileError result,
              const base::PlatformFileInfo& file_info,
              const FilePath& platform_path) {
     if (!callback_.is_null()) {
       reply_message_proxy_->PostTask(FROM_HERE,
           Bind(&GetFileInfoDelegate::ReplyOnCallingThread,
                this,
                result,
                file_info,
@@ skipping 59 matching lines @@
 
     GURL unused;
     Reply(base::PLATFORM_FILE_OK, results, directory->NeedsRefresh(&unused));
   }
 
   virtual void OnError(base::PlatformFileError error) OVERRIDE {
     Reply(error, std::vector<base::FileUtilProxy::Entry>(), false);
   }
 
  private:
-
   // Relays reply back to the callback on calling thread.
   void Reply(base::PlatformFileError result,
              const std::vector<base::FileUtilProxy::Entry>& file_list,
              bool has_more) {
     if (!callback_.is_null()) {
       reply_message_proxy_->PostTask(FROM_HERE,
           Bind(&ReadDirectoryDelegate::ReplyOnCallingThread,
                this,
                result,
                file_list,
@@ skipping 35 matching lines @@
     scoped_refptr<GetFileInfoDelegate> delegate(
         new GetFileInfoDelegate(file_system_, FilePath(), callback));
     delegate->OnError(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   file_system_->FindFileByPath(
       file_path, new GetFileInfoDelegate(file_system_, file_path, callback));
 }
 
+void GDataFileSystemProxy::Copy(const GURL& src_file_url,
+    const GURL& dest_file_url,
+    const FileSystemOperationInterface::StatusCallback& callback) {
+  FilePath src_file_path, dest_file_path;
+  if (!ValidateUrl(src_file_url, &src_file_path) ||
+      !ValidateUrl(dest_file_url, &dest_file_path)) {
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
+    return;
+  }
+
+  file_system_->Copy(src_file_path, dest_file_path, callback);
+}
+
+void GDataFileSystemProxy::Move(const GURL& src_file_url,
+    const GURL& dest_file_url,
+    const FileSystemOperationInterface::StatusCallback& callback) {
+  FilePath src_file_path, dest_file_path;
+  if (!ValidateUrl(src_file_url, &src_file_path) ||
+      !ValidateUrl(dest_file_url, &dest_file_path)) {
+    MessageLoopProxy::current()->PostTask(FROM_HERE,
+         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
+    return;
+  }
+
+  file_system_->Move(src_file_path, dest_file_path, callback);
+}
 
 void GDataFileSystemProxy::ReadDirectory(const GURL& file_url,
     const FileSystemOperationInterface::ReadDirectoryCallback& callback) {
   FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     scoped_refptr<ReadDirectoryDelegate> delegate(
         new ReadDirectoryDelegate(file_system_, FilePath(), callback));
     delegate->OnError(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
@@ skipping 35 matching lines @@
   FilePath raw_path;
   fileapi::FileSystemType type = fileapi::kFileSystemTypeUnknown;
   if (!fileapi::CrackFileSystemURL(url, NULL, &type, file_path) ||
       type != fileapi::kFileSystemTypeExternal) {
     return false;
   }
   return true;
 }
 
 }  // namespace gdata