gdata: Support mouting archive file in GData 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 <sys/stat.h>
 
 #include <set>
@@ skipping 36 matching lines @@
 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 char kMountedArchiveFileExtension[] = "mounted";
 
 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[] =
@@ skipping 1791 matching lines @@
   if (regular_file) {
     properties->file_md5 = regular_file->file_md5();
     properties->mime_type = regular_file->content_mime_type();
     properties->content_url = regular_file->content_url();
     properties->alternate_url = regular_file->alternate_url();
     properties->is_hosted_document = regular_file->is_hosted_document();
   }
   return true;
 }
 
+bool GDataFileSystem::IsUnderGDataCacheDirectory(const FilePath& path) const {
+  return gdata_cache_path_ == path || gdata_cache_path_.IsParent(path);
+}
+
 FilePath GDataFileSystem::GetGDataCacheTmpDirectory() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP];
 }
 
 FilePath GDataFileSystem::GetGDataTempDownloadFolderPath() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOWNLOADS];
 }
 
 FilePath GDataFileSystem::GetGDataTempDocumentFolderPath() const {
   return cache_paths_[GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS];
@@ skipping 128 matching lines @@
                                 GetWeakPtrForCurrentThread(),
                                 callback);
   }
 
   if (to_pin)
     Pin(resource_id, md5, cache_callback);
   else
     Unpin(resource_id, md5, cache_callback);
 }
 
+void GDataFileSystem::SetMountedState(const FilePath& file_path, bool to_mount,
+                                      const SetMountedStateCallback& callback) {

[kuan, 2012/04/18 00:36:36]

Any method that accesses cache files (i.e. in cache subdirectories) or cache
memory (i.e. root_->GetCacheEntry) needs to happen:
1) on IO Thread Pool with sequenced ID (or FILE thread temporarily for now)
2) after InitializeCacheOnIOThreadPool
If u refer to StoreToCache example, it first calls InitializeCacheIfNecessary
then post StoreToCacheOnIOThreadPool task to blocking pool, with a reply on the
calling thread.  u  need to adopt the same logic, to ensure that SetMountedState
happens after cache initialization and on io thread pool (or file thread for
now).

[hshi1, 2012/04/18 01:29:05]

(1) In terms of the complexity of the change, is there any difference if I were
to make this happen on the FILE thread vs on the IO Thread Pool? Currently
SetMountedState is called on the UI thread
(AddMountFunction::GetLocalPathsResponseOnUIThread) so it seems that I will need
to post the task anyway.

(2) In the StoreToCache example the same resource_id and md5 parameters are
passed to the request task and reply task in
PostBlockingPoolSequencedTaskAndReply. Is there any way for the request task to
pass parameters to the reply task? In case to_mount==true, it is necessary to
pass back the mounted path (GCache/v1/persistent/<resource_id>.mounted) to the
callback which will then call disk mount manager to mount the path.

On 2012/04/18 00:36:36, kuan wrote:

[kuan, 2012/04/18 11:32:54]

just call PostBlockingPoolSequencedTaskAndReply to post task and reply.
internally, that method now posts task to FILE thread.  initially, cache tasks
happened on IO thread pool, with a sequenced id for sequencing.  they were later
changed to FILE thread.  i'm positive we'll revert to IO thread pool in the near
future.  
fyi, this task needs to happen and queued on the same thread as all cache tasks.
 it doesn't matter which thread your method is called, even if it's called on
the same thread as that for cache task, u have to post task to _queue_ it in
thread pool with the same sequence id as other cache tasks.  when we switch back
to IO thread pool later, your method will never have the same sequence id as
that for cache tasks, so if the task is not posted to io thread pool with
sequenced id, it will be out of sync with other cache tasks.
PostBlockingPoolSequencedTaskAndReply will shield you from having to change the
thread later, and all cache APIs call that.
 
refer to GetFromCacheInternal and GetFromCacheOnIOThreadPool which also passes a
FilePath from task to reply.

[hshi1, 2012/04/18 17:28:15]

Thanks for the explanation, I think I understood most of it, but can you clarify
one more thing? For binding the task and reply, how do I decide whether I need
to pass in either base::Unretained(this) or GetWeakPtrForCurrentThread() as the
2nd argument?

On 2012/04/18 11:32:54, kuan wrote:

[kuan, 2012/04/18 17:39:20]

u use base::Unretained(this) for the task to run on IO thread that needs to
access GDataFileSystem's class members (like root_->GetCacheEntry).
u use GetWeakPtrForCurrentThread() for the reply to run on the thread where u
call PostBlockingPoolSequencedTaskAndReply.

+  base::AutoLock lock(lock_);
+
+  FilePath base_name = file_path.BaseName();
+  FilePath::StringType resource_id = base_name.RemoveExtension().value();
+  FilePath::StringType extension = base_name.Extension();
+  FilePath::StringType md5;
+  if (to_mount && !extension.empty()) {
+    // FilePath::Extension returns ".", so strip it.
+    md5 = GDataFileBase::UnescapeUtf8FileName(extension.substr(1));
+  }
+  GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
+                                                               md5);
+  // Report error if cache entry does not exist, or
+  // if the mounted state of the cache entry is incorrect.
+  if (!entry || (entry->IsMounted() == to_mount)) {
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(FROM_HERE,
+          base::Bind(callback, base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
+                     FilePath()));
+    }
+    return;
+  }
+
+  // Returns path of the file if it were to be unmounted.

[kuan, 2012/04/18 00:36:36]

nit: s/Returns/Gets/

+  FilePath unmounted_path = GetCacheFilePath(
+                                resource_id, md5,
+                                entry->IsPinned() ?
+                                    GDataRootDirectory::CACHE_TYPE_PERSISTENT :
+                                    GDataRootDirectory::CACHE_TYPE_TMP,
+                                CACHED_FILE_FROM_SERVER);
+  // Returns path of the file if it were to be mounted.

[kuan, 2012/04/18 00:36:36]

nit: s/Returns/Gets/

+  FilePath mounted_path = GetCacheFilePath(
+                              resource_id, md5,
+                              GDataRootDirectory::CACHE_TYPE_PERSISTENT,
+                              CACHED_FILE_MOUNTED);
+  // Determine the source and destination paths for moving the cache blob.
+  FilePath src_path, dst_path;
+  if (to_mount) {
+    src_path = unmounted_path;
+    dst_path = mounted_path;
+    entry->cache_state = GDataFile::SetCacheMounted(entry->cache_state);

[kuan, 2012/04/18 00:36:36]

please use a variable "int cache_state" to store the returned state.

+  } else {
+    src_path = mounted_path;
+    dst_path = unmounted_path;
+    entry->cache_state = GDataFile::ClearCacheMounted(entry->cache_state);
+  }
+  // Move cache blob from source path to destination path.
+  base::PlatformFileError error = ModifyCacheState(
+                                      src_path, dst_path,
+                                      GDataFileSystem::FILE_OPERATION_MOVE,
+                                      FilePath(), false);
+  if (error == base::PLATFORM_FILE_OK) {
+    // Now that cache operation is complete, update cache map
+    root_->UpdateCacheMap(resource_id, md5,
+                          GDataRootDirectory::CACHE_TYPE_PERSISTENT,
+                          entry->cache_state);
+  }
+  if (!callback.is_null()) {
+    MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(callback, error, dst_path));
+  }
+}
+
 void GDataFileSystem::OnSetPinStateCompleted(
     const FileOperationCallback& callback,
     base::PlatformFileError error,
     const std::string& resource_id,
     const std::string& md5) {
   callback.Run(error);
 }
 
 void GDataFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
@@ skipping 1151 matching lines @@
   DCHECK(sub_dir_type != GDataRootDirectory::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 (file_origin == CACHED_FILE_LOCALLY_MODIFIED) {
     DCHECK(sub_dir_type == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
     base_name += FilePath::kExtensionSeparator;
     base_name += kLocallyModifiedFileExtension;
+  } else if (file_origin == CACHED_FILE_MOUNTED) {
+    DCHECK(sub_dir_type == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
+    base_name += FilePath::kExtensionSeparator;
+    base_name += kMountedArchiveFileExtension;
   } else if (!md5.empty()) {
     base_name += FilePath::kExtensionSeparator;
     base_name += GDataFileBase::EscapeUtf8FileName(md5);
   }
   return cache_paths_[sub_dir_type].Append(base_name);
 }
 
 void GDataFileSystem::GetFromCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const GetFromCacheCallback& callback) {
@@ skipping 222 matching lines @@
     FilePath* cache_file_path) {
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // Lock to access cache map.
   base::AutoLock lock(lock_);
 
   GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
                                                                md5);
   if (entry && entry->IsPresent()) {
+    CachedFileOrigin file_origin;
+    if (entry->IsMounted()) {
+      file_origin = CACHED_FILE_MOUNTED;
+    } else if (entry->IsDirty()) {
+      file_origin = CACHED_FILE_LOCALLY_MODIFIED;
+    } else {
+      file_origin = CACHED_FILE_FROM_SERVER;
+    }
     *cache_file_path = GetCacheFilePath(
         resource_id,
         md5,
         entry->sub_dir_type,
-        entry->IsDirty() ? CACHED_FILE_LOCALLY_MODIFIED :
-                           CACHED_FILE_FROM_SERVER);
+        file_origin);
     *error = base::PLATFORM_FILE_OK;
   } else {
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 }
 
 void GDataFileSystem::GetCacheStateOnIOThreadPool(
     const std::string& resource_id,
     const std::string& md5,
     base::PlatformFileError* error,
@@ skipping 837 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata