gdata:: Add GDataFileSystem::GetFile().

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 <vector>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ skipping 384 matching lines @@
           documents_service_bound_to_ui_thread_,
           params.feed_url,
           base::Bind(&GDataFileSystem::OnGetDocuments,
                      file_system_bound_to_ui_thread_,
                      params)));
 }
 
 void GDataFileSystem::Remove(const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
-  GURL document_url = GetDocumentUrlFromPath(file_path);
-  if (document_url.is_empty()) {
+  GDataFileBase* file_info = GetGDataFileInfoFromPath(file_path);
+  if (!file_info) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     }
+    return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &DocumentsService::DeleteDocument,
           documents_service_bound_to_ui_thread_,
-          document_url,
+          file_info->self_url(),
           base::Bind(&GDataFileSystem::OnRemovedDocument,
                      file_system_bound_to_ui_thread_,
                      callback,
                      file_path,
                      // MessageLoopProxy is used to run |callback| on the
-                     // thread where Remove() was called.
+                     // thread where this function was called.
                      base::MessageLoopProxy::current())));
 }
 
 void GDataFileSystem::CreateDirectory(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   CreateDirectoryInternal(directory_path, is_exclusive, is_recursive, callback,
                           base::MessageLoopProxy::current());
@@ skipping 58 matching lines @@
                             file_system_bound_to_ui_thread_,
                             CreateDirectoryParams(
                                 first_missing_path,
                                 directory_path,
                                 is_exclusive,
                                 is_recursive,
                                 callback,
                                 reply_proxy))));
 }
 
+void GDataFileSystem::GetFile(const FilePath& file_path,
+                              const GetFileCallback& callback) {
+  GDataFileBase* file_info = GetGDataFileInfoFromPath(file_path);
+  if (!file_info) {
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(callback,
+                     base::PLATFORM_FILE_ERROR_NOT_FOUND,
+                     FilePath()));
+    }
+    return;
+  }
+
+  // TODO(satorux): We should get a file from the cache if it's present, but
+  // the caching layer is not implemented yet. For now, always download from
+  // the cloud.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &DocumentsService::DownloadFile,
+          documents_service_bound_to_ui_thread_,
+          file_info->content_url(),
+          base::Bind(&GDataFileSystem::OnFileDownloaded,
+                     file_system_bound_to_ui_thread_,
+                     callback,
+                     // MessageLoopProxy is used to run |callback| on the
+                     // thread where this function was called.
+                     base::MessageLoopProxy::current())));
+}
+
 void GDataFileSystem::UnsafeFindFileByPath(
     const FilePath& file_path, scoped_refptr<FindFileDelegate> delegate) {
   lock_.AssertAcquired();
 
   std::vector<FilePath::StringType> components;
   file_path.GetComponents(&components);
 
   GDataDirectory* current_dir = root_.get();
   FilePath directory_path;
   for (size_t i = 0; i < components.size() && current_dir; i++) {
@@ skipping 31 matching lines @@
         delegate->OnFileFound(file_iter->second->AsGDataFile());
       else
         delegate->OnError(base::PLATFORM_FILE_ERROR_NOT_FOUND);
 
       return;
     }
   }
   delegate->OnError(base::PLATFORM_FILE_ERROR_NOT_FOUND);
 }
 
-GURL GDataFileSystem::GetDocumentUrlFromPath(const FilePath& file_path) {
+GDataFileBase* GDataFileSystem::GetGDataFileInfoFromPath(
+    const FilePath& file_path) {
   base::AutoLock lock(lock_);
   // Find directory element within the cached file system snapshot.
   scoped_refptr<ReadOnlyFindFileDelegate> find_delegate(
       new ReadOnlyFindFileDelegate());
   UnsafeFindFileByPath(file_path, find_delegate);
   if (!find_delegate->file())
-    return GURL();
+    return NULL;
 
-  return find_delegate->file()->self_url();
+  return find_delegate->file();
 }
 
 void GDataFileSystem::OnCreateDirectoryCompleted(
     const CreateDirectoryParams& params,
     GDataErrorCode status,
     base::Value* created_entry) {
   base::PlatformFileError error = GDataToPlatformError(status);
   if (error != base::PLATFORM_FILE_OK) {
     if (!params.callback.is_null())
       params.proxy->PostTask(FROM_HERE, base::Bind(params.callback, error));
@@ skipping 83 matching lines @@
   base::PlatformFileError error = GDataToPlatformError(status);
 
   if (error == base::PLATFORM_FILE_OK)
     error = RemoveFileFromFileSystem(file_path);
 
   if (!callback.is_null()) {
     message_loop_proxy->PostTask(FROM_HERE, base::Bind(callback, error));
   }
 }
 
+void GDataFileSystem::OnFileDownloaded(
+    const GetFileCallback& callback,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    GDataErrorCode status,
+    const GURL& content_url,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  base::PlatformFileError error = GDataToPlatformError(status);
+
+  if (!callback.is_null()) {
+    message_loop_proxy->PostTask(FROM_HERE,
+                                 base::Bind(callback, error, file_path));
+  }
+}
+
 base::PlatformFileError GDataFileSystem::RemoveFileFromFileSystem(
     const FilePath& file_path) {
   // We need to lock here as well (despite FindFileByPath lock) since directory
   // instance below is a 'live' object.
   base::AutoLock lock(lock_);
 
   // Find directory element within the cached file system snapshot.
   scoped_refptr<ReadOnlyFindFileDelegate> update_delegate(
       new ReadOnlyFindFileDelegate());
   UnsafeFindFileByPath(file_path, update_delegate);
@@ skipping 169 matching lines @@
 
 GDataFileSystemFactory::~GDataFileSystemFactory() {
 }
 
 ProfileKeyedService* GDataFileSystemFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   return new GDataFileSystem(profile);
 }
 
 }  // namespace gdata