GData downloads cleanup

chrome/browser/chromeos/gdata/gdata_file_system.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.h"
 
 #include <errno.h>
 
 #include <utility>
 
@@ skipping 18 matching lines @@
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/mime_util.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 content::BrowserThread;
 
+namespace gdata {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 const FilePath::CharType kGDataRootDirectory[] = FILE_PATH_LITERAL("gdata");
 const char kFeedField[] = "feed";
 const char kWildCard[] = "*";
 const char kLocallyModifiedFileExtension[] = "local";
 
 const FilePath::CharType kGDataCacheVersionDir[] = FILE_PATH_LITERAL("v1");
 const FilePath::CharType kGDataCacheMetaDir[] = FILE_PATH_LITERAL("meta");
 const FilePath::CharType kGDataCachePinnedDir[] = FILE_PATH_LITERAL("pinned");
 const FilePath::CharType kGDataCacheOutgoingDir[] =
     FILE_PATH_LITERAL("outgoing");
 const FilePath::CharType kGDataCachePersistentDir[] =
     FILE_PATH_LITERAL("persistent");
 const FilePath::CharType kGDataCacheTmpDir[] = FILE_PATH_LITERAL("tmp");
 const FilePath::CharType kGDataCacheTmpDownloadsDir[] =
     FILE_PATH_LITERAL("tmp/downloads");
 const FilePath::CharType kGDataCacheTmpDocumentsDir[] =
     FILE_PATH_LITERAL("tmp/documents");
 const FilePath::CharType kLastFeedFile[] = FILE_PATH_LITERAL("last_feed.json");
 const char kGDataFileSystemToken[] = "GDataFileSystemToken";
 const FilePath::CharType kAccountMetadataFile[] =
     FILE_PATH_LITERAL("account_metadata.json");
 const FilePath::CharType kSymLinkToDevNull[] = FILE_PATH_LITERAL("/dev/null");
 
 // Converts gdata error code into file platform error code.
-base::PlatformFileError GDataToPlatformError(gdata::GDataErrorCode status) {
+base::PlatformFileError GDataToPlatformError(GDataErrorCode status) {
   switch (status) {
-    case gdata::HTTP_SUCCESS:
-    case gdata::HTTP_CREATED:
+    case HTTP_SUCCESS:
+    case HTTP_CREATED:
       return base::PLATFORM_FILE_OK;
-    case gdata::HTTP_UNAUTHORIZED:
-    case gdata::HTTP_FORBIDDEN:
+    case HTTP_UNAUTHORIZED:
+    case HTTP_FORBIDDEN:
       return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
-    case gdata::HTTP_NOT_FOUND:
+    case HTTP_NOT_FOUND:
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-    case gdata::GDATA_PARSE_ERROR:
-    case gdata::GDATA_FILE_ERROR:
+    case GDATA_PARSE_ERROR:
+    case GDATA_FILE_ERROR:
       return base::PLATFORM_FILE_ERROR_ABORT;
     default:
       return base::PLATFORM_FILE_ERROR_FAILED;
   }
 }
 
 // Converts system error to file platform error code.
 // This is copied and modified from base/platform_file_posix.cc.
 // TODO(kuan): base/platform.h should probably export this.
 base::PlatformFileError SystemToPlatformError(int error) {
@@ skipping 56 matching lines @@
 
 // Modifies cache state of file on IO thread pool, which involves:
 // - moving or copying file (per |file_operation_type|) from |source_path| to
 //  |dest_path| if they're different
 // - deleting symlink if |symlink_path| is not empty
 // - creating symlink if |symlink_path| is not empty and |create_symlink| is
 //   true.
 base::PlatformFileError ModifyCacheState(
     const FilePath& source_path,
     const FilePath& dest_path,
-    gdata::GDataFileSystem::FileOperationType file_operation_type,
+    GDataFileSystem::FileOperationType file_operation_type,
     const FilePath& symlink_path,
     bool create_symlink) {
   // Move or copy |source_path| to |dest_path| if they are different.
   if (source_path != dest_path) {
     bool success = false;
-    if (file_operation_type == gdata::GDataFileSystem::FILE_OPERATION_MOVE)
+    if (file_operation_type == GDataFileSystem::FILE_OPERATION_MOVE)
       success = file_util::Move(source_path, dest_path);
-    else if (file_operation_type == gdata::GDataFileSystem::FILE_OPERATION_COPY)
+    else if (file_operation_type ==
+        GDataFileSystem::FILE_OPERATION_COPY)
       success = file_util::CopyFile(source_path, dest_path);
     if (!success) {
       base::PlatformFileError error = SystemToPlatformError(errno);
       LOG(ERROR) << "Error "
                  << (file_operation_type ==
-                     gdata::GDataFileSystem::FILE_OPERATION_MOVE ?
+                     GDataFileSystem::FILE_OPERATION_MOVE ?
                      "moving " : "copying ")
                  << source_path.value()
                  << " to " << dest_path.value()
                  << ": " << strerror(errno);
       return error;
     } else {
       DVLOG(1) << (file_operation_type ==
-                   gdata::GDataFileSystem::FILE_OPERATION_MOVE ?
+                   GDataFileSystem::FILE_OPERATION_MOVE ?
                    "Moved " : "Copied ")
                << source_path.value()
                << " to " << dest_path.value();
     }
   } else {
     DVLOG(1) << "No need to move file: source = destination";
   }
 
   if (symlink_path.empty())
     return base::PLATFORM_FILE_OK;
@@ skipping 81 matching lines @@
       DVLOG(1) << "Error deleting " << current.value();
     else
       DVLOG(1) << "Deleted " << current.value();
   }
 }
 
 // Invoked upon completion of TransferRegularFile initiated by Copy.
 //
 // |callback| is run on the thread represented by |relay_proxy|.
 void OnTransferRegularFileCompleteForCopy(
-    const gdata::FileOperationCallback& callback,
+    const FileOperationCallback& callback,
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     base::PlatformFileError error) {
   if (!callback.is_null())
     relay_proxy->PostTask(FROM_HERE, base::Bind(callback, error));
 }
 
 // Runs GetFileCallback with pointers dereferenced.
 // Used for PostTaskAndReply().
-void RunGetFileCallbackHelper(const gdata::GetFileCallback& callback,
+void RunGetFileCallbackHelper(const GetFileCallback& callback,
                               base::PlatformFileError* error,
                               FilePath* file_path,
                               std::string* mime_type,
-                              gdata::GDataFileType* file_type) {
+                              GDataFileType* file_type) {
   DCHECK(error);
   DCHECK(file_path);
   DCHECK(mime_type);
   DCHECK(file_type);
 
   if (!callback.is_null())
     callback.Run(*error, *file_path, *mime_type, *file_type);
 }
 
 // Ditto for CacheOperationCallback.
 void RunCacheOperationCallbackHelper(
-    const gdata::CacheOperationCallback& callback,
+    const CacheOperationCallback& callback,
     base::PlatformFileError* error,
     const std::string& resource_id,
     const std::string& md5) {
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 }
 
 // Ditto for GetFromCacheCallback.
 void RunGetFromCacheCallbackHelper(
-    const gdata::GetFromCacheCallback& callback,
+    const GetFromCacheCallback& callback,
     base::PlatformFileError* error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& gdata_file_path,
     FilePath* cache_file_path) {
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5, gdata_file_path, *cache_file_path);
 }
 
 void RunGetCacheStateCallbackHelper(
-    const gdata::GetCacheStateCallback& callback,
+    const GetCacheStateCallback& callback,
     base::PlatformFileError* error,
     int* cache_state) {
   DCHECK(error);
   DCHECK(cache_state);
 
   if (!callback.is_null())
     callback.Run(*error, *cache_state);
 }
 
 }  // namespace
 
-namespace gdata {
-
 // FindFileDelegate class implementation.
 
 FindFileDelegate::~FindFileDelegate() {
 }
 
 // FindFileCallbackRelayDelegate class implementation.
 // This class is used to relay calls between sync and async versions
 // of FindFileByPath(Sync|Async) calls.
 class FindFileCallbackRelayDelegate : public FindFileDelegate {
  public:
@@ skipping 356 matching lines @@
     JSONFileValueSerializer serializer(local_file_path);
     scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
     if (value.get() && value->GetAsDictionary(&dict_value))
       dict_value->GetString("resource_id", resource_id);
   }
 }
 
 void GDataFileSystem::StartFileUploadOnUIThread(
     const FileOperationCallback& callback,
     base::PlatformFileError* error,
     UploadFileInfo* upload_file_info) {

[asanka, 2012/03/28 22:02:33]

Nit: Might be clearer if this took a scoped_ptr<> as well. That way it would be
clear from the binding site in TransferRegularFile() that ownership is being
transferred.

[achuithb, 2012/03/28 23:27:11]

scoped_ptr can't be used with PostTaskAndReply properly, or couldn't be.

https://groups.google.com/a/chromium.org/group/chromium-dev/msg/ddd7942f93b8ed4b
Not sure if this is fixed now...

   // This method needs to run on the UI thread as required by
   // GDataUploader::UploadFile().
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(upload_file_info);
 
   GDataSystemService* service =
       GDataSystemServiceFactory::GetForProfile(profile_);
 
   if (*error == base::PLATFORM_FILE_OK) {
     if (!service)
       *error = base::PLATFORM_FILE_ERROR_FAILED;
   }
 
   if (*error != base::PLATFORM_FILE_OK) {
     if (!callback.is_null())
       callback.Run(*error);
 
     return;
   }
 
   upload_file_info->completion_callback =
       base::Bind(&GDataFileSystem::OnTransferCompleted,
                  GetWeakPtrForCurrentThread(),
-                 upload_file_info->file_path,
-                 upload_file_info->gdata_path,
                  callback);
 
-  service->uploader()->UploadFile(upload_file_info);
+  service->uploader()->UploadFile(scoped_ptr<UploadFileInfo>(upload_file_info));
 }
 
 void GDataFileSystem::OnTransferCompleted(
-    const FilePath& local_file_path,
-    const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     base::PlatformFileError error,
-    DocumentEntry* entry) {
-  if (error == base::PLATFORM_FILE_OK && entry) {
-    AddUploadedFile(remote_dest_file_path.DirName(),
-                    entry,
-                    local_file_path,
+    UploadFileInfo* upload_file_info) {
+  DCHECK(upload_file_info);
+  if (error == base::PLATFORM_FILE_OK && upload_file_info->entry.get()) {
+    AddUploadedFile(upload_file_info->gdata_path.DirName(),
+                    upload_file_info->entry.get(),
+                    upload_file_info->file_path,
                     FILE_OPERATION_COPY);
   }
   if (!callback.is_null())
     callback.Run(error);
+
+  GDataSystemService* service =
+      GDataSystemServiceFactory::GetForProfile(profile_);
+  if (service)
+    service->uploader()->DeleteUpload(upload_file_info);
 }
 
 // static.
 void GDataFileSystem::CreateUploadFileInfoOnIOThreadPool(
     const FilePath& local_file,
     const FilePath& remote_dest_file,
     base::PlatformFileError* error,
     UploadFileInfo* upload_file_info) {
   DCHECK(error);
   DCHECK(upload_file_info);
@@ skipping 1725 matching lines @@
 
   GDataDirectory* parent_dir = file->parent();
   if (!parent_dir->RemoveFile(file))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   NotifyDirectoryChanged(parent_dir->GetFilePath());
   return base::PLATFORM_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(const FilePath& virtual_dir_path,
-                                      gdata::DocumentEntry* entry,
+                                      DocumentEntry* entry,
                                       const FilePath& file_content_path,
                                       FileOperationType cache_operation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry) {
     NOTREACHED();
     return;
   }
 
   std::string resource_id;
@@ skipping 148 matching lines @@
                  FILE_OPERATION_MOVE,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFromCacheCallbackHelper,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
                  FilePath() /* gdata_file_path */,
                  base::Owned(cache_file_path)));
-
 }
 
 void GDataFileSystem::CommitDirtyInCache(
     const std::string& resource_id,
     const std::string& md5,
     const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   base::PlatformFileError* error =
       new base::PlatformFileError(base::PLATFORM_FILE_OK);
@@ skipping 904 matching lines @@
       BrowserThread::FILE,
       from_here,
       base::Bind(&GDataFileSystem::RunTaskOnIOThreadPool,
                  base::Unretained(this),
                  request_task),
       reply_task);
   DCHECK(posted);
 }
 
 }  // namespace gdata