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 502 matching lines @@
 void ReadOnlyFindFileDelegate::OnDone(base::PlatformFileError error,
                                       const FilePath& directory_path,
                                       GDataFileBase* file) {
   DCHECK(!file_);
   if (error == base::PLATFORM_FILE_OK)
     file_ = file;
   else
     file_ = NULL;
 }
 
+// GDataFileProperties struct implementation.
+
+GDataFileProperties::GDataFileProperties() : is_hosted_document(false) {
+}
+
+GDataFileProperties::~GDataFileProperties() {
+}
+
 // GDataFileSystem::CreateDirectoryParams struct implementation.
 
 GDataFileSystem::CreateDirectoryParams::CreateDirectoryParams(
     const FilePath& created_directory_path,
     const FilePath& target_directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback)
     : 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,
                                  GDataSyncClientInterface* sync_client)
     : 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(
@@ skipping 473 matching lines @@
     if (error != base::PLATFORM_FILE_OK)
       temp_file.clear();
 
     relay_proxy->PostTask(FROM_HERE,
         base::Bind(callback, error, temp_file, HOSTED_DOCUMENT));
   }
 }
 
 void GDataFileSystem::GetFile(const FilePath& file_path,
                               const GetFileCallback& callback) {
-  base::AutoLock lock(lock_);
-  GDataFileBase* file_info = GetGDataFileInfoFromPath(file_path);
-  if (!file_info) {
+  GDataFileProperties file_properties;
+  if (!GetFileInfoFromPath(file_path, &file_properties)) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback,
                      base::PLATFORM_FILE_ERROR_NOT_FOUND,
                      FilePath(),
                      REGULAR_FILE));
     }
     return;
   }
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
-  GDataFile* gdata_file = file_info->AsGDataFile();
-  if (gdata_file && gdata_file->is_hosted_document()) {
+  if (file_properties.is_hosted_document) {
     BrowserThread::PostBlockingPoolTask(FROM_HERE,
         base::Bind(&GDataFileSystem::CreateDocumentJsonFileOnIOThreadPool,
-                   gdata_file->edit_url(),
-                   gdata_file->resource_id(),
+                   file_properties.edit_url,
+                   file_properties.resource_id,
                    callback,
                    base::MessageLoopProxy::current()));
     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(file_properties.resource_id,
+                                             file_properties.file_md5,
+                                             CACHE_TYPE_TMP,
+                                             CACHED_FILE_FROM_SERVER);
+  GetFromCache(file_properties.resource_id, file_properties.file_md5,
+               base::Bind(
+                   &GDataFileSystem::OnGetFileFromCache,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   GetFileFromCacheParams(file_path,
+                                          local_tmp_path,
+                                          file_properties.content_url,
+                                          file_properties.resource_id,
+                                          file_properties.file_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,
+                                        REGULAR_FILE));
+    }
+
+    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, GDataFileProperties* properties) {
+  DCHECK(properties);
   base::AutoLock lock(lock_);
   GDataFileBase* file = GetGDataFileInfoFromPath(file_path);
   if (!file)
     return false;
 
-  *file_info = file->file_info();
+  properties->file_info = file->file_info();
+  properties->resource_id = file->resource_id();
+
+  GDataFile* regular_file = file->AsGDataFile();
+  if (regular_file) {
+    properties->file_md5 = regular_file->file_md5();
+    properties->content_url = regular_file->content_url();
+    properties->edit_url = regular_file->edit_url();
+    properties->is_hosted_document = regular_file->is_hosted_document();
+  }
   return true;
 }
 
 FilePath GDataFileSystem::GetGDataCacheTmpDirectory() {
     return cache_paths_[CACHE_TYPE_TMP];
 }
 
 GDataFileBase* GDataFileSystem::GetGDataFileInfoFromPath(
     const FilePath& file_path) {
   lock_.AssertAcquired();
@@ skipping 482 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, REGULAR_FILE);
+  // 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,
+                                      REGULAR_FILE));
+  }
+}
+
+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 291 matching lines @@
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   return base::PLATFORM_FILE_OK;
 }
 
 //===================== GDataFileSystem: Cache entry points ====================
 
 FilePath GDataFileSystem::GetCacheFilePath(const std::string& resource_id,
                                            const std::string& md5,
                                            CacheSubdir subdir_id,
-                                           bool is_local) {
+                                           CachedFileOrigin file_origin) {
   DCHECK(subdir_id != CACHE_TYPE_META);
   // Runs on any thread.
   // Filename is formatted as resource_id.md5, i.e. resource_id is the base
   // name and md5 is the extension.
   std::string base_name = GDataFileBase::EscapeUtf8FileName(resource_id);
-  if (is_local) {
+  if (file_origin == CACHED_FILE_LOCALLY_MODIFIED) {
     DCHECK(subdir_id == CACHE_TYPE_PERSISTENT);
     base_name += FilePath::kExtensionSeparator;
     base_name += kLocallyModifiedFileExtension;
   } else if (!md5.empty()) {
     base_name += FilePath::kExtensionSeparator;
     base_name += GDataFileBase::EscapeUtf8FileName(md5);
   }
   return cache_paths_[subdir_id].Append(base_name);
 }
 
@@ skipping 14 matching lines @@
       FROM_HERE,
       base::Bind(StoreToCacheOnIOThreadPool,
                  StoreToCacheParams(
                      resource_id,
                      md5,
                      source_path,
                      callback,
                      GetCacheFilePath(resource_id,
                                       md5,
                                       CACHE_TYPE_TMP,
-                                      false  /* is_local */),
+                                      CACHED_FILE_FROM_SERVER),
                      base::Bind(&GDataFileSystem::OnStoredToCache,
                                 weak_ptr_factory_.GetWeakPtr()),
                      base::MessageLoopProxy::current())));
 }
 
 void GDataFileSystem::GetFromCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const GetFromCacheCallback& callback) {
   GetFromCacheInternal(resource_id, md5, FilePath(), callback);
 }
 
 void GDataFileSystem::RemoveFromCache(const std::string& resource_id,
                                       const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   // Lock to access cache map.
   base::AutoLock lock(lock_);
   root_->RemoveFromCacheMap(resource_id);
 
   // Post task to delete all cache versions of resource_id.
   // If $resource_id.* is passed to DeleteStaleCacheVersions, then all
   // $resource_id.* will be deleted since no file will match "$resource_id.*".
   FilePath files_to_delete = GetCacheFilePath(resource_id,
                                               kWildCard,
                                               CACHE_TYPE_TMP,
-                                              false  /* is_local */);
+                                              CACHED_FILE_FROM_SERVER);
   BrowserThread::PostBlockingPoolSequencedTask(
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(DeleteStaleCacheVersionsWithCallback,
                  resource_id,
                  callback,
                  files_to_delete,
                  base::MessageLoopProxy::current()));
 
 }
 
 void GDataFileSystem::Pin(const std::string& resource_id,
                           const std::string& md5,
                           const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   BrowserThread::PostBlockingPoolSequencedTask(
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(ModifyCacheStatusOnIOThreadPool,
                  ModifyCacheStatusParams(
                      resource_id,
                      md5,
                      callback,
                      GDataRootDirectory::CACHE_PINNED,
                      true,
-    GetCacheFilePath(resource_id,
-                     md5,
-                     CACHE_TYPE_TMP,
-                     false  /* is_local */),
+                     GetCacheFilePath(resource_id,
+                                      md5,
+                                      CACHE_TYPE_TMP,
+                                      CACHED_FILE_FROM_SERVER),
                      base::Bind(&GDataFileSystem::OnFilePinned,
                                 weak_ptr_factory_.GetWeakPtr()),
                      base::MessageLoopProxy::current())));
 }
 
 void GDataFileSystem::Unpin(const std::string& resource_id,
                             const std::string& md5,
                             const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   BrowserThread::PostBlockingPoolSequencedTask(
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(ModifyCacheStatusOnIOThreadPool,
                  ModifyCacheStatusParams(
                      resource_id,
                      md5,
                      callback,
                      GDataRootDirectory::CACHE_PINNED,
                      false,
                      GetCacheFilePath(resource_id,
                                       md5,
                                       CACHE_TYPE_TMP,
-                                      false  /* is_local */),
+                                      CACHED_FILE_FROM_SERVER),
                      base::Bind(&GDataFileSystem::OnFileUnpinned,
                                 weak_ptr_factory_.GetWeakPtr()),
                      base::MessageLoopProxy::current())));
 }
 
 //========= GDataFileSystem: Cache tasks that ran on io thread pool ============
 
 void GDataFileSystem::InitializeCacheOnIOThreadPool() {
   base::PlatformFileError error = CreateCacheDirectories(cache_paths_);
 
@@ skipping 75 matching lines @@
 
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   FilePath path;
 
   // Lock to access cache map.
   base::AutoLock lock(lock_);
   if (root_->CacheFileExists(resource_id, md5)) {
     path = GetCacheFilePath(resource_id,
                             md5,
                             CACHE_TYPE_TMP,
-                            false  /* is_local */);
+                            CACHED_FILE_FROM_SERVER);
   } else {
     error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 
   // Invoke callback.
   if (!callback.is_null())
     callback.Run(error, resource_id, md5, gdata_file_path, path);
 }
 
 void GDataFileSystem::OnRemovedFromCache(base::PlatformFileError error,
@@ skipping 136 matching lines @@
 }
 
 ProfileKeyedService* GDataFileSystemFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   return new GDataFileSystem(profile,
                              new DocumentsService,
                              new GDataSyncClient);
 }
 
 }  // namespace gdata