gdata: Support mounting archive files in GData cache.

chrome/browser/chromeos/gdata/gdata_file_system.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #pragma once
 
 #include <sys/stat.h>
 
@@ skipping 58 matching lines @@
                             GDataEntry* entry)>
     FindEntryCallback;
 
 // Used to get files from the file system.
 typedef base::Callback<void(base::PlatformFileError error,
                             const FilePath& file_path,
                             const std::string& mime_type,
                             GDataFileType file_type)>
     GetFileCallback;
 
+// Callback for SetMountedState.
+typedef base::Callback<void(base::PlatformFileError error,
+                            const FilePath& file_path)>
+    SetMountedStateCallback;
+
 // Used for file operations like removing files.
 typedef base::Callback<void(base::PlatformFileError error,
                             base::ListValue* feed_list)>
     GetJsonDocumentCallback;
 
 // Used to get available space for the account from GData.
 typedef base::Callback<void(base::PlatformFileError error,
                             int bytes_total,
                             int bytes_used)>
     GetAvailableSpaceCallback;
@@ skipping 96 matching lines @@
   virtual void Initialize() = 0;
 
   // Adds and removes the observer.
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;
 
   // Enum defining origin of a cached file.
   enum CachedFileOrigin {
     CACHED_FILE_FROM_SERVER = 0,
     CACHED_FILE_LOCALLY_MODIFIED,
+    CACHED_FILE_MOUNTED,
   };
 
   // Enum defining type of file operation e.g. copy or move, etc.
   // For now, it's used for StoreToCache.
   enum FileOperationType {
     FILE_OPERATION_MOVE = 0,
     FILE_OPERATION_COPY,
   };
 
   // Authenticates the user by fetching the auth token as
@@ skipping 153 matching lines @@
   // otherwise.
   virtual void GetCacheState(const std::string& resource_id,
                              const std::string& md5,
                              const GetCacheStateCallback& callback) = 0;
 
   // Finds file object by |file_path| and returns its key |properties|.
   // Returns true if file was found.
   virtual bool GetFileInfoFromPath(const FilePath& gdata_file_path,
                                    GDataFileProperties* properties) = 0;
 
+  // Returns true if the given path is under gdata cache directory, i.e.
+  // <user_profile_dir>/GCache/v1
+  virtual bool IsUnderGDataCacheDirectory(const FilePath& path) const = 0;
+
   // Returns the tmp sub-directory under gdata cache directory, i.e.
   // <user_profile_dir>/GCache/v1/tmp
   virtual FilePath GetGDataCacheTmpDirectory() const = 0;
 
   // Returns the tmp downloads sub-directory under gdata cache directory, i.e.
   // <user_profile_dir>/GCache/v1/tmp/downloads/
   virtual FilePath GetGDataTempDownloadFolderPath() const = 0;
 
   // Returns the tmp documents sub-directory under gdata cache directory, i.e.
   // <user_profile_dir>/GCache/v1/tmp/documents/
@@ skipping 15 matching lines @@
       CachedFileOrigin file_orign) const = 0;
 
   // Fetches the user's Account Metadata to find out current quota information
   // and returns it to the callback.
   virtual void GetAvailableSpace(const GetAvailableSpaceCallback& callback) = 0;
 
   // Pin or unpin file.
   virtual void SetPinState(const FilePath& file_path, bool to_pin,
                            const FileOperationCallback& callback) = 0;
 
+  // Marks or unmarks a file as locally mounted.
+  // When marked as mounted, the file is prevented from being modified
+  // or evicted from cache.
+  virtual void SetMountedState(const FilePath& file_path, bool to_mount,
+                               const SetMountedStateCallback& callback) = 0;
+
   // Creates a new file from |entry| under |virtual_dir_path|. Stored its
   // content from |file_content_path| into the cache.
   virtual void AddUploadedFile(const FilePath& virtual_dir_path,
                                DocumentEntry* entry,
                                const FilePath& file_content_path,
                                FileOperationType cache_operation) = 0;
 
   // Returns true if hosted documents should be hidden.
   virtual bool hide_hosted_documents() = 0;
 };
@@ skipping 46 matching lines @@
   virtual bool CancelOperation(const FilePath& file_path) OVERRIDE;
   virtual void AddOperationObserver(
       GDataOperationRegistry::Observer* observer) OVERRIDE;
   virtual void RemoveOperationObserver(
       GDataOperationRegistry::Observer* observer) OVERRIDE;
   virtual void GetCacheState(const std::string& resource_id,
                              const std::string& md5,
                              const GetCacheStateCallback& callback) OVERRIDE;
   virtual bool GetFileInfoFromPath(const FilePath& gdata_file_path,
                                    GDataFileProperties* properties) OVERRIDE;
+  virtual bool IsUnderGDataCacheDirectory(const FilePath& path) const OVERRIDE;
   virtual FilePath GetGDataCacheTmpDirectory() const OVERRIDE;
   virtual FilePath GetGDataTempDownloadFolderPath() const OVERRIDE;
   virtual FilePath GetGDataTempDocumentFolderPath() const OVERRIDE;
   virtual FilePath GetGDataCachePinnedDirectory() const OVERRIDE;
   virtual FilePath GetGDataCachePersistentDirectory() const OVERRIDE;
   virtual FilePath GetCacheFilePath(
       const std::string& resource_id,
       const std::string& md5,
       GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
       CachedFileOrigin file_orign) const OVERRIDE;
   virtual void GetAvailableSpace(
       const GetAvailableSpaceCallback& callback) OVERRIDE;
   // Calls private Pin or Unpin methods with |callback|.
   virtual void SetPinState(const FilePath& file_path, bool pin,
                            const FileOperationCallback& callback) OVERRIDE;
+  virtual void SetMountedState(
+      const FilePath& file_path,
+      bool to_mount,
+      const SetMountedStateCallback& callback) OVERRIDE;
   virtual void AddUploadedFile(const FilePath& virtual_dir_path,
                                DocumentEntry* entry,
                                const FilePath& file_content_path,
                                FileOperationType cache_operation) OVERRIDE;
   virtual bool hide_hosted_documents() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
@@ skipping 687 matching lines @@
   // Task posted from Unpin to modify cache state on the IO thread pool, which
   // involves the following:
   // - moves |source_path| to |dest_path| in tmp dir if file is
   //   not dirty
   // - deletes symlink from pinned dir
   void UnpinOnIOThreadPool(const std::string& resource_id,
                            const std::string& md5,
                            FileOperationType file_operation_type,
                            base::PlatformFileError* error);
 
+  // Task posted from SetMountedState to modify cache state on the IO thread
+  // pool, which involves the following:
+  // - moves |source_path| to |dest_path|

[tbarzic, 2012/04/23 18:03:22]

what are |source_path| and |dest_path|?

[hshi, 2012/04/23 19:01:09]

In the case we're mounting, the |source_path| is the original (unmounted) path
to the cache blob, and |dest_path| is the mounted path; if we're unmounting it
is the opposite. 

Do you want me to put more explanation here? I'm just following the examples
such as the comments in UnpinOnIOThreadPool.

[hshi, 2012/04/23 20:45:47]

Done.

+  void SetMountedStateOnIOThreadPool(const FilePath& file_path,
+                                     bool to_mount,
+                                     base::PlatformFileError* error,
+                                     FilePath* cache_file_path);
+
   // Task posted from MarkDirtyInCache to modify cache state on the IO thread
   // pool, which involves the following:
   // - moves |source_path| to |dest_path| in persistent dir, where
   //   |source_path| has .<md5> extension and |dest_path| has .local extension
   // - if file is pinned, updates symlink in pinned dir to reference dirty file
   void MarkDirtyInCacheOnIOThreadPool(const std::string& resource_id,
                                       const std::string& md5,
                                       FileOperationType file_operation_type,
                                       base::PlatformFileError* error,
                                       FilePath* cache_file_path);
@@ skipping 182 matching lines @@
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_