Wired GDataFileSystem::GetFile() method with internal cache.

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 "base/bind.h"
 #include "base/eintr_wrapper.h"
@@ skipping 178 matching lines @@
       md5(in_md5),
       source_path(in_source_path),
       operation_callback(in_operation_callback),
       dest_path(in_dest_path),
       modification_callback(in_modification_callback),
       relay_proxy(in_relay_proxy) {
 }
 
 StoreToCacheParams::~StoreToCacheParams() {
 }
 

[satorux1, 2012/03/20 04:51:17]

nit: remove the blank line.

[zel, 2012/03/20 05:24:25]

Done.

+
 //=================== ModifyCacheStatusParams implementations ==================
 
 ModifyCacheStatusParams::ModifyCacheStatusParams(
     const std::string& in_resource_id,
     const std::string& in_md5,
     const gdata::CacheOperationCallback& in_operation_callback,
     gdata::GDataRootDirectory::CacheStatusFlags in_flags,
     bool in_enable,
     const FilePath& in_file_path,
     const CacheStatusModificationCallback& in_modification_callback,
@@ skipping 321 matching lines @@
     : created_directory_path(created_directory_path),
       target_directory_path(target_directory_path),
       is_exclusive(is_exclusive),
       is_recursive(is_recursive),
       callback(callback) {
 }
 
 GDataFileSystem::CreateDirectoryParams::~CreateDirectoryParams() {
 }
 
+//=================== GetFileFromCacheParams implementation ===================
+
+GDataFileSystem::GetFileFromCacheParams::GetFileFromCacheParams(
+    const FilePath& virtual_file_path,
+    const FilePath& local_tmp_path,
+    const GURL& content_url,
+    const std::string& resource_id,
+    const std::string& md5,
+    scoped_refptr<base::MessageLoopProxy> proxy,
+    const GetFileCallback& callback)
+    : virtual_file_path(virtual_file_path),
+      local_tmp_path(local_tmp_path),
+      content_url(content_url),
+      resource_id(resource_id),
+      md5(md5),
+      proxy(proxy),
+      callback(callback) {
+}
+
+GDataFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
+}
+
 // GDataFileSystem class implementatsion.
 
 GDataFileSystem::GDataFileSystem(Profile* profile,
                                  DocumentsServiceInterface* documents_service)
     : profile_(profile),
       documents_service_(documents_service),
       gdata_uploader_(new GDataUploader(ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       gdata_download_observer_(new GDataDownloadObserver()),
       on_cache_initialized_(new base::WaitableEvent(
           true /* manual reset*/, false /* initially not signaled*/)),
@@ skipping 442 matching lines @@
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
 }
 
 void GDataFileSystem::GetFile(const FilePath& file_path,
                               const GetFileCallback& callback) {
-  base::AutoLock lock(lock_);
-  GDataFileBase* file_info = GetGDataFileInfoFromPath(file_path);
-  if (!file_info) {
+  std::string resource_id;
+  std::string md5;
+  GURL content_url;
+  base::PlatformFileInfo file_info;
+  if (!GetFileInfoFromPath(file_path, &file_info,
+                           &resource_id, &md5, &content_url)) {
     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.
+  // Returns absolute path of the file if it were cached or to be cached.
+  FilePath local_tmp_path = GetCacheFilePath(resource_id, md5, CACHE_TYPE_TMP,
+                                             false  /* is_local */);

[satorux1, 2012/03/20 04:51:17]

Would be easier to read if it's enum like PINNED_FILE.

http://www.chromium.org/developers/coding-style

Begin to prefer enumerated values (e.g. "DELETE_AFTER_USE/KEEP_ALIVE_AFTER_USE")
to booleans ("bool delete_after_use") as function arguments the more the
following cases apply:

[zel, 2012/03/20 05:24:25]

Done.

+  GetFromCache(resource_id, md5,
+               base::Bind(
+                   &GDataFileSystem::OnGetFileFromCache,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   GetFileFromCacheParams(file_path,
+                                          local_tmp_path,
+                                          content_url,
+                                          resource_id,
+                                          md5,
+                                          base::MessageLoopProxy::current(),
+                                          callback)));
+}
+
+void GDataFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
+                                         base::PlatformFileError error,
+                                         const std::string& resource_id,
+                                         const std::string& md5,
+                                         const FilePath& gdata_file_path,
+                                         const FilePath& cache_file_path) {
+  // Have we found the file in cache? If so, return it back to the caller.
+  if (error == base::PLATFORM_FILE_OK) {
+    if (!params.callback.is_null()) {
+      params.proxy->PostTask(FROM_HERE,
+                             base::Bind(params.callback,
+                                        error,
+                                        cache_file_path));
+    }
+
+    return;
+  }
+
+  // If cache file is not found, try to download it from the server instead.
   documents_service_->DownloadFile(
-      file_info->GetFilePath(),
-      file_info->content_url(),
+      params.virtual_file_path,
+      params.local_tmp_path,
+      params.content_url,
       base::Bind(&GDataFileSystem::OnFileDownloaded,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 params));
 }
 
 void GDataFileSystem::InitiateUpload(
     const std::string& file_name,
     const std::string& content_type,
     int64 content_length,
     const FilePath& destination_directory,
     const FilePath& virtual_path,
     const InitiateUploadCallback& callback) {
   GURL destination_directory_url =
@@ skipping 106 matching lines @@
         delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
       }
 
       return;
     }
   }
   delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
 }
 
 bool GDataFileSystem::GetFileInfoFromPath(
-    const FilePath& file_path, base::PlatformFileInfo* file_info) {
+    const FilePath& file_path, base::PlatformFileInfo* file_info,
+    std::string* resource_id, std::string* md5, GURL* content_url) {
+  DCHECK(file_info);
   base::AutoLock lock(lock_);
   GDataFileBase* file = GetGDataFileInfoFromPath(file_path);
   if (!file)
     return false;
 
   *file_info = file->file_info();
+  if (resource_id)
+    *resource_id = file->resource_id();
+
+  GDataFile* regular_file = file->AsGDataFile();
+  if (regular_file) {
+    if (md5)
+      *md5 = regular_file->file_md5();
+
+    if (content_url)
+      *content_url = regular_file->content_url();
+  }
   return true;
 }
 
 GDataFileBase* GDataFileSystem::GetGDataFileInfoFromPath(
     const FilePath& file_path) {
   lock_.AssertAcquired();
   // Find directory element within the cached file system snapshot.
   ReadOnlyFindFileDelegate find_delegate;
   UnsafeFindFileByPath(file_path, &find_delegate);
   return find_delegate.file();
@@ skipping 478 matching lines @@
 
   if (error == base::PLATFORM_FILE_OK)
     error = RemoveFileFromFileSystem(file_path);
 
   if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::OnFileDownloaded(
-    const GetFileCallback& callback,
+    const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
-    const FilePath& file_path) {
+    const FilePath& downloaded_file_path) {
   base::PlatformFileError error = GDataToPlatformError(status);
 
-  if (!callback.is_null()) {
-    callback.Run(error, file_path);
+  // Make sure that downloaded file is properly stored in cache. We don't have
+  // to wait for this operation to finish since the user can already use the
+  // downloaded file.
+  if (error == base::PLATFORM_FILE_OK) {
+    StoreToCache(params.resource_id,
+                 params.md5,
+                 downloaded_file_path,
+                 base::Bind(&GDataFileSystem::OnDownloadStoredToCache,
+                            weak_ptr_factory_.GetWeakPtr()));
+
   }
+  if (!params.callback.is_null()) {
+    params.proxy->PostTask(FROM_HERE,
+                           base::Bind(params.callback,
+                                      error,
+                                      downloaded_file_path));
+  }
+}
+
+void GDataFileSystem::OnDownloadStoredToCache(base::PlatformFileError error,
+                                              const std::string& resource_id,
+                                              const std::string& md5) {
+  // Nothing much to do here for now.
 }
 
 base::PlatformFileError GDataFileSystem::RenameFileOnFilesystem(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     FilePath* updated_file_path) {
   DCHECK(updated_file_path);
 
   base::AutoLock lock(lock_);
   GDataFileBase* file = GetGDataFileInfoFromPath(file_path);
@@ skipping 663 matching lines @@
 
 GDataFileSystemFactory::~GDataFileSystemFactory() {
 }
 
 ProfileKeyedService* GDataFileSystemFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   return new GDataFileSystem(profile, new DocumentsService);
 }
 
 }  // namespace gdata