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 <utility>
@@ skipping 35 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 1740 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->edit_url = regular_file->edit_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);

[Ben Chan, 2012/04/17 20:57:53]

nit: can this fit in one line?

also, please add unit test.

+}
+
 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,
+                                      const std::string& file_name,

[tbarzic, 2012/04/17 21:33:13]

I don't see that you really use file_name and mount_type..
Why don't you bind it to the callback before you call the method.

+                                      const std::string& mount_type,
+                                      const SetMountedStateCallback& callback) {
+  std::string resource_id = file_path.BaseName().RemoveExtension().value();

[tbarzic, 2012/04/17 21:33:13]

I think you have to acquire |lock_| before you access cache.
Same in ClearMountedState

+  GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
+                                                               std::string());

[Ben Chan, 2012/04/17 20:57:53]

Should we pass md5 to GetCacheEntry here?

+  if (!entry || entry->IsMounted()) {
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(FROM_HERE,
+          base::Bind(callback, base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
+              FilePath(), std::string(), std::string()));
+    }
+    return;
+  }

[Ben Chan, 2012/04/17 20:57:53]

nit: line break

+  base::PlatformFileError error;

[Ben Chan, 2012/04/17 20:57:53]

this can be defined in the scope below.

+  {
+    base::AutoLock lock(lock_);

[tbarzic, 2012/04/17 21:33:13]

You should move this to the method scope.

+    // Returns original path of the file in cache
+    FilePath src_path = GetCacheFilePath(resource_id, entry->md5,
+                            entry->IsPinned() ?
+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT :
+                            GDataRootDirectory::CACHE_TYPE_TMP,
+                            CACHED_FILE_FROM_SERVER);
+    // Returns destination path of the file if it were to be mounted
+    FilePath dst_path = GetCacheFilePath(resource_id, entry->md5,
+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT,
+                            CACHED_FILE_MOUNTED_ARCHIVE);
+    // Move cache blob to the mounted path
+    error = ModifyCacheState(src_path, dst_path,

[Ben Chan, 2012/04/17 20:57:53]

base::PlatformFileError error = ...

+                             GDataFileSystem::FILE_OPERATION_MOVE,
+                             FilePath(), false);
+    if (error == base::PLATFORM_FILE_OK) {
+      // Now that cache operation is complete, update cache map
+      entry->cache_state = GDataFile::SetCacheMounted(entry->cache_state);
+      root_->UpdateCacheMap(resource_id, entry->md5,
+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT,
+                            entry->cache_state);
+    }
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(FROM_HERE,
+          base::Bind(callback, error, dst_path, file_name, mount_type));
+    }
+  }
+}
+
+void GDataFileSystem::ClearMountedState(const FilePath& file_path,
+                                        const FileOperationCallback& callback) {

[tbarzic, 2012/04/17 21:33:13]

This looks very similar to SetMountState..

Why don't you try to merge these two in one method SetMountedState(file_path,
is_mounted, callback)

[hshi, 2012/04/17 22:36:45]

Yes I had initially attempted to merge the two, but unfortunately the
SetMountedStateCallback requires passing back the new path to the cached blob
(persistent/<resource_id>.mounted) whereas ClearMountedState does not. However I
can simplify the SetMountedState as Ben suggested and bind the file_name and
mount_type before the call.

[tbarzic, 2012/04/17 23:01:10]

when I think about it, it may have sense to pass dst_path to ClearMountedState
callback too (it can be ignored in file_browser_pricate_api for now)

+  std::string resource_id = file_path.BaseName().RemoveExtension().value();
+  GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
+                                                               std::string());
+  if (!entry || !entry->IsMounted()) {
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(FROM_HERE,
+          base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
+    }
+    return;
+  }

[Ben Chan, 2012/04/17 20:57:53]

nit: line break

+  base::PlatformFileError error;

[Ben Chan, 2012/04/17 20:57:53]

this can be defined within the scope below

+  {
+    base::AutoLock lock(lock_);
+    // Returns mounted path of the file in cache
+    FilePath src_path = GetCacheFilePath(resource_id, entry->md5,
+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT,

[Ben Chan, 2012/04/17 20:57:53]

nit: thisseems like a weird indentation

+                            CACHED_FILE_MOUNTED_ARCHIVE);
+    // Returns destination path of the file if it were to be unmounted
+    FilePath dst_path = GetCacheFilePath(resource_id, entry->md5,
+                            entry->IsPinned() ?

[Ben Chan, 2012/04/17 20:57:53]

ditto

+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT :
+                            GDataRootDirectory::CACHE_TYPE_TMP,
+                            CACHED_FILE_FROM_SERVER);
+    // Move cache blob to the destination path
+    error = ModifyCacheState(src_path, dst_path,

[Ben Chan, 2012/04/17 20:57:53]

base::PlatformFileError error = ...

+                             GDataFileSystem::FILE_OPERATION_MOVE,
+                             FilePath(), false);
+    if (error == base::PLATFORM_FILE_OK) {
+      // Now that cache operation is complete, update cache map
+      entry->cache_state = GDataFile::ClearCacheMounted(entry->cache_state);
+      root_->UpdateCacheMap(resource_id, entry->md5,
+                            entry->IsPinned() ?
+                            GDataRootDirectory::CACHE_TYPE_PERSISTENT :
+                            GDataRootDirectory::CACHE_TYPE_TMP,
+                            entry->cache_state);
+    }
+    if (!callback.is_null()) {
+      MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, error));
+    }
+  }
+}
+
 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 1086 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_ARCHIVE) {
+    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 226 matching lines @@
   // Lock to access cache map.
   base::AutoLock lock(lock_);
 
   GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
                                                                md5);
   if (entry && entry->IsPresent()) {
     *cache_file_path = GetCacheFilePath(
         resource_id,
         md5,
         entry->sub_dir_type,
+        entry->IsMounted() ? CACHED_FILE_MOUNTED_ARCHIVE :

[tbarzic, 2012/04/17 21:33:13]

This looks a bit ugly (at least to me:) )

         entry->IsDirty() ? CACHED_FILE_LOCALLY_MODIFIED :
                            CACHED_FILE_FROM_SERVER);
     *error = base::PLATFORM_FILE_OK;
   } else {
     *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 }
 
 void GDataFileSystem::GetCacheStateOnIOThreadPool(
     const std::string& resource_id,
@@ skipping 839 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