gdata: Support mounting archive files 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 39 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 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 431 matching lines @@
     const std::string& md5,
     const FilePath& gdata_file_path,
     FilePath* cache_file_path) {
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5, gdata_file_path, *cache_file_path);
 }
 
+// Ditto for SetMountedStateCallback
+void RunSetMountedStateCallbackHelper(
+    const SetMountedStateCallback& callback,
+    base::PlatformFileError* error,
+    FilePath* cache_file_path) {
+  DCHECK(error);
+  DCHECK(cache_file_path);
+
+  if (!callback.is_null())
+    callback.Run(*error, *cache_file_path);
+}
+
 void RunGetCacheStateCallbackHelper(
     const GetCacheStateCallback& callback,
     base::PlatformFileError* error,
     int* cache_state) {
   DCHECK(error);
   DCHECK(cache_state);
 
   if (!callback.is_null())
     callback.Run(*error, *cache_state);
 }
@@ skipping 1483 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 94 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) {
+  InitializeCacheIfNecessary();
+
+  base::PlatformFileError* error =
+      new base::PlatformFileError(base::PLATFORM_FILE_OK);
+  FilePath* cache_file_path = new FilePath;
+  PostBlockingPoolSequencedTaskAndReply(
+      kGDataFileSystemToken,
+      FROM_HERE,
+      base::Bind(&GDataFileSystem::SetMountedStateOnIOThreadPool,
+                 base::Unretained(this),
+                 file_path,
+                 to_mount,
+                 error,
+                 cache_file_path),
+      base::Bind(&RunSetMountedStateCallbackHelper,
+                 callback,
+                 base::Owned(error),
+                 base::Owned(cache_file_path)));
+}
+
+void GDataFileSystem::SetMountedStateOnIOThreadPool(
+    const FilePath& file_path,
+    bool to_mount,
+    base::PlatformFileError *error,
+    FilePath* cache_file_path) {
+  DCHECK(error);
+  DCHECK(cache_file_path);
+
+  // Lock to access cache map.
+  base::AutoLock lock(lock_);
+
+  // Parse file path to obtain resource_id, md5 and extra_extension.
+  std::string resource_id;
+  std::string md5;
+  std::string extra_extension;
+  util::ParseCacheFilePath(file_path, &resource_id, &md5, &extra_extension);
+  // The extra_extension shall be ".mounted" iff we're unmounting.
+  DCHECK(!to_mount == (extra_extension == kMountedArchiveFileExtension));
+
+  // Get cache entry associated with the resource_id and md5
+  GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
+                                                               md5);
+  if (!entry) {
+    *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    return;
+  }
+  if (to_mount == entry->IsMounted()) {
+    *error = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+    return;
+  }
+
+  // Get the subdir type and path for the unmounted state.
+  GDataRootDirectory::CacheSubDirectoryType unmounted_subdir =
+      entry->IsPinned() ? GDataRootDirectory::CACHE_TYPE_PERSISTENT :
+                          GDataRootDirectory::CACHE_TYPE_TMP;
+  FilePath unmounted_path = GetCacheFilePath(resource_id, md5, unmounted_subdir,
+                                             CACHED_FILE_FROM_SERVER);
+
+  // Get the subdir type and path for the mounted state.
+  GDataRootDirectory::CacheSubDirectoryType mounted_subdir =
+      GDataRootDirectory::CACHE_TYPE_PERSISTENT;
+  FilePath mounted_path = GetCacheFilePath(resource_id, md5, mounted_subdir,
+                                           CACHED_FILE_MOUNTED);
+
+  // Determine the source and destination paths for moving the cache blob.
+  FilePath source_path;
+  GDataRootDirectory::CacheSubDirectoryType dest_subdir;
+  int cache_state = entry->cache_state;
+  if (to_mount) {
+    source_path = unmounted_path;
+    *cache_file_path = mounted_path;
+    dest_subdir = mounted_subdir;
+    cache_state = GDataFile::SetCacheMounted(cache_state);
+  } else {
+    source_path = mounted_path;
+    *cache_file_path = unmounted_path;
+    dest_subdir = unmounted_subdir;
+    cache_state = GDataFile::ClearCacheMounted(cache_state);
+  }
+
+  // Move cache blob from source path to destination path.
+  *error = ModifyCacheState(source_path, *cache_file_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, dest_subdir, cache_state);
+  }
+}
+
 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 1070 matching lines @@
 FilePath GDataFileSystem::GetCacheFilePath(
     const std::string& resource_id,
     const std::string& md5,
     GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
     CachedFileOrigin file_origin) const {
   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 = GDataEntry::EscapeUtf8FileName(resource_id);
+  std::string base_name = util::EscapeCacheFileName(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 (!md5.empty()) {
     base_name += FilePath::kExtensionSeparator;
-    base_name += GDataEntry::EscapeUtf8FileName(md5);
+    base_name += util::EscapeCacheFileName(md5);
+  }
+  // For mounted archives the filename is formatted as resource_id.md5.mounted,
+  // i.e. resource_id.md5 is the base name and ".mounted" is the extension
+  if (file_origin == CACHED_FILE_MOUNTED) {
+     DCHECK(sub_dir_type == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
+     base_name += FilePath::kExtensionSeparator;
+     base_name += kMountedArchiveFileExtension;
   }
   return cache_paths_[sub_dir_type].Append(base_name);
 }
 
 void GDataFileSystem::GetFileFromCacheByResourceIdAndMd5(
     const std::string& resource_id,
     const std::string& md5,
     const GetFileFromCacheCallback& callback) {
   GetFileFromCacheByResourceIdAndMd5Internal(
       resource_id, md5, FilePath(), 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 36 matching lines @@
   int cache_state = GDataFile::CACHE_STATE_PRESENT;
   GDataRootDirectory::CacheSubDirectoryType sub_dir_type =
       GDataRootDirectory::CACHE_TYPE_TMP;
 
   GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(
       resource_id, md5);
 
   // If file was previously pinned, store it in persistent dir and create
   // symlink in pinned dir.
   if (entry) {  // File exists in cache.
-    // If file is dirty, return error.
-    if (entry->IsDirty()) {
-      LOG(WARNING) << "Can't store a file to replace a dirty file: res_id="
-                   << resource_id
+    // If file is dirty or mounted, return error.
+    if (entry->IsDirty() || entry->IsMounted()) {
+      LOG(WARNING) << "Can't store a file to replace a "
+                   << (entry->IsDirty() ? "dirty" : "mounted")
+                   << " file: res_id=" << resource_id
                    << ", md5=" << md5;
       *error = base::PLATFORM_FILE_ERROR_IN_USE;
       return;
     }
 
     cache_state |= entry->cache_state;
 
     // If file is pinned, determines destination path.
     if (entry->IsPinned()) {
       sub_dir_type = GDataRootDirectory::CACHE_TYPE_PERSISTENT;
@@ skipping 78 matching lines @@
 
     // Set sub_dir_type to PINNED to indicate that the file doesn't exist.
     // When the file is finally downloaded and StoreToCache called, it will be
     // moved to persistent directory.
     sub_dir_type = GDataRootDirectory::CACHE_TYPE_PINNED;
   } else {  // File exists in cache, determines destination path.
     cache_state |= entry->cache_state;
 
     // Determine source and destination paths.
 
-    // If file is dirty, don't move it, so determine |dest_path| and set
-    // |source_path| the same, because ModifyCacheState only moves files if
+    // If file is dirty or mounted, don't move it, so determine |dest_path| and
+    // set |source_path| the same, because ModifyCacheState only moves files if
     // source and destination are different.
-    if (entry->IsDirty()) {
+    if (entry->IsDirty() || entry->IsMounted()) {
       DCHECK_EQ(GDataRootDirectory::CACHE_TYPE_PERSISTENT, entry->sub_dir_type);
       dest_path = GetCacheFilePath(resource_id,
                                    md5,
                                    entry->sub_dir_type,
                                    CACHED_FILE_LOCALLY_MODIFIED);
       source_path = dest_path;
     } else {
       // Gets the current path of the file in cache.
       source_path = GetCacheFilePath(resource_id,
                                      md5,
@@ skipping 59 matching lines @@
     return;
   }
 
   // Entry exists in cache, determines source and destination paths.
 
   FilePath source_path;
   FilePath dest_path;
   GDataRootDirectory::CacheSubDirectoryType sub_dir_type =
       GDataRootDirectory::CACHE_TYPE_TMP;
 
-  // If file is dirty, don't move it, so determine |dest_path| and set
-  // |source_path| the same, because ModifyCacheState moves files if source
+  // If file is dirty or mounted, don't move it, so determine |dest_path| and
+  // set |source_path| the same, because ModifyCacheState moves files if source
   // and destination are different.
-  if (entry->IsDirty()) {
+  if (entry->IsDirty() || entry->IsMounted()) {
     sub_dir_type = GDataRootDirectory::CACHE_TYPE_PERSISTENT;
     DCHECK_EQ(sub_dir_type, entry->sub_dir_type);
     dest_path = GetCacheFilePath(resource_id,
                                  md5,
                                  entry->sub_dir_type,
                                  CACHED_FILE_LOCALLY_MODIFIED);
     source_path = dest_path;
   } else {
     // Gets the current path of the file in cache.
     source_path = GetCacheFilePath(resource_id,
@@ skipping 311 matching lines @@
   // Lock to access cache map.
   base::AutoLock lock(lock_);
 
   // MD5 is not passed into RemoveFromCache and hence
   // RemoveFromCacheOnIOThreadPool, because we would delete all cache files
   // corresponding to <resource_id> regardless of the md5.
   // So, search for entry in cache without taking md5 into account.
   GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(
       resource_id, std::string());
 
-  // If entry doesn't exist or is dirty in cache, nothing to do.
-  if (!entry || entry->IsDirty()) {
-    DVLOG(1) << "Entry " << (entry ? "is dirty" : "doesn't exist")
+  // If entry doesn't exist or is dirty or mounted in cache, nothing to do.
+  if (!entry || entry->IsDirty() || entry->IsMounted()) {
+    DVLOG(1) << "Entry is "
+             << (entry ? (entry->IsDirty() ? "dirty" : "mounted") :
+                         "non-existent")
              << " in cache, not removing";
     *error = base::PLATFORM_FILE_OK;
     return;
   }
 
   // Determine paths to delete all cache versions of |resource_id| in
   // persistent, tmp and pinned directories.
   std::vector<FilePath> paths_to_delete;
 
   // For files in persistent and tmp dirs, delete files that match
@@ skipping 101 matching lines @@
   file_util::FileEnumerator enumerator(
       cache_paths_[sub_dir_type],
       false,  // not recursive
       static_cast<file_util::FileEnumerator::FileType>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::SHOW_SYM_LINKS),
       kWildCard);
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     // Extract resource_id and md5 from filename.
-    FilePath base_name = current.BaseName();
     std::string resource_id;
     std::string md5;
-
-    // Pinned and outgoing symlinks have no extension.
-    if (sub_dir_type == GDataRootDirectory::CACHE_TYPE_PINNED ||
-        sub_dir_type == GDataRootDirectory::CACHE_TYPE_OUTGOING) {
-      resource_id = GDataEntry::UnescapeUtf8FileName(base_name.value());
-    } else {
-      FilePath::StringType extension = base_name.Extension();
-      if (!extension.empty()) {
-        // FilePath::Extension returns ".", so strip it.
-        md5 = GDataEntry::UnescapeUtf8FileName(extension.substr(1));
-      }
-      resource_id = GDataEntry::UnescapeUtf8FileName(
-          base_name.RemoveExtension().value());
-    }
+    std::string extra_extension;
+    util::ParseCacheFilePath(current, &resource_id, &md5, &extra_extension);
 
     // Determine cache state.
     int cache_state = GDataFile::CACHE_STATE_NONE;
     // If we're scanning pinned directory and if entry already exists, just
     // update its pinned state.
     if (sub_dir_type == GDataRootDirectory::CACHE_TYPE_PINNED) {
       GDataRootDirectory::CacheMap::iterator iter =
           cache_map->find(resource_id);
       if (iter != cache_map->end()) {  // Entry exists, update pinned state.
         GDataRootDirectory::CacheEntry* entry = iter->second;
@@ skipping 11 matching lines @@
       // ignore this outgoing symlink and move on.
       GDataRootDirectory::CacheMap::iterator iter =
           cache_map->find(resource_id);
       if (iter != cache_map->end()) {  // Entry exists, update dirty state.
         GDataRootDirectory::CacheEntry* entry = iter->second;
         entry->cache_state = GDataFile::SetCacheDirty(entry->cache_state);
       } else {
         NOTREACHED() << "Dirty cache file MUST have actual file blob";
       }
       continue;
+    } else if (extra_extension == kMountedArchiveFileExtension) {
+      // Mounted archives in cache should be unmounted upon logout/shutdown.
+      // But if we encounter a mounted file at start, delete it and create an
+      // entry with not PRESENT state.
+      DCHECK(sub_dir_type == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
+      file_util::Delete(current, false);
     } else {
       // Scanning other directories means that cache file is actually present.
       cache_state = GDataFile::SetCachePresent(cache_state);
     }
 
     // Create and insert new entry into cache map.
     GDataRootDirectory::CacheEntry* entry = new GDataRootDirectory::CacheEntry(
         md5, sub_dir_type, cache_state);
     cache_map->insert(std::make_pair(resource_id, entry));
   }
@@ skipping 89 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