drive: Rename FileCache methods in a blocking pool centric manner

chrome/browser/chromeos/drive/file_cache.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_DRIVE_FILE_CACHE_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_FILE_CACHE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 44 matching lines @@
 // implementation that reports fake free disk space.
 class FreeDiskSpaceGetterInterface {
  public:
   virtual ~FreeDiskSpaceGetterInterface() {}
   virtual int64 AmountOfFreeDiskSpace() = 0;
 };
 
 // FileCache is used to maintain cache states of FileSystem.
 //
 // All non-static public member functions, unless mentioned otherwise (see
-// GetCacheFilePath() for example), should be called from the UI thread.
+// GetCacheFilePath() for example), should be run with |blocking_task_runner|.
 class FileCache {
  public:
   // Enum defining GCache subdirectory location.
   // This indexes into |FileCache::cache_paths_| vector.
   enum CacheSubDirectoryType {
     CACHE_TYPE_META = 0,       // Downloaded feeds.
     CACHE_TYPE_OUTGOING,       // Symlinks to files in persistent or tmp dir to
                                // be uploaded.
     CACHE_TYPE_PERSISTENT,     // Files that are pinned or modified locally,
                                // not evictable, hopefully.
@@ skipping 11 matching lines @@
   };
 
   // |cache_root_path| specifies the root directory for the cache. Sub
   // directories will be created under the root directory.
   //
   // |blocking_task_runner| is used to post a task to the blocking worker
   // pool for file operations. Must not be null.
   //
   // |free_disk_space_getter| is used to inject a custom free disk space
   // getter for testing. NULL must be passed for production code.
+  //
+  // Must be called on the UI thread.
   FileCache(const base::FilePath& cache_root_path,
-             base::SequencedTaskRunner* blocking_task_runner,
-             FreeDiskSpaceGetterInterface* free_disk_space_getter);
+            base::SequencedTaskRunner* blocking_task_runner,
+            FreeDiskSpaceGetterInterface* free_disk_space_getter);
 
   // Returns the sub-directory under drive cache directory for the given sub
   // directory type. Example:  <user_profile_dir>/GCache/v1/tmp
   //
   // Can be called on any thread.
   base::FilePath GetCacheDirectoryPath(
       CacheSubDirectoryType sub_dir_type) const;
 
   // Returns true if the given path is under drive cache directory, i.e.
   // <user_profile_dir>/GCache/v1
   //
   // Can be called on any thread.
   bool IsUnderFileCacheDirectory(const base::FilePath& path) const;
 
   // Adds observer.
+  // Must be called on the UI thread.
   void AddObserver(FileCacheObserver* observer);
 
   // Removes observer.
+  // Must be called on the UI thread.
   void RemoveObserver(FileCacheObserver* observer);
 
   // Gets the cache entry for file corresponding to |resource_id| and |md5|
   // and runs |callback| with true and the entry found if entry exists in cache
   // map.  Otherwise, runs |callback| with false.
   // |md5| can be empty if only matching |resource_id| is desired, which may
   // happen when looking for pinned entries where symlinks' filenames have no
   // extension and hence no md5.
   // |callback| must not be null.
-  void GetCacheEntry(const std::string& resource_id,
-                     const std::string& md5,
-                     const GetCacheEntryCallback& callback);
+  // Must be called on the UI thread.
+  void GetCacheEntryOnUIThread(const std::string& resource_id,
+                               const std::string& md5,
+                               const GetCacheEntryCallback& callback);
 
   // Iterates all files in the cache and calls |iteration_callback| for each
   // file. |completion_callback| is run upon completion.
-  void Iterate(const CacheIterateCallback& iteration_callback,
-               const base::Closure& completion_callback);
+  // Must be called on the UI thread.
+  void IterateOnUIThread(const CacheIterateCallback& iteration_callback,
+                         const base::Closure& completion_callback);
 
   // Frees up disk space to store the given number of bytes, while keeping
   // kMinFreeSpace bytes on the disk, if needed.
   // Runs |callback| with true when we successfully manage to have enough space.
-  void FreeDiskSpaceIfNeededFor(int64 num_bytes,
-                                const InitializeCacheCallback& callback);
+  // Must be called on the UI thread.
+  void FreeDiskSpaceIfNeededForOnUIThread(
+      int64 num_bytes,
+      const InitializeCacheCallback& callback);
 
   // Checks if file corresponding to |resource_id| and |md5| exists in cache.
   // |callback| must not be null.
-  void GetFile(const std::string& resource_id,
-               const std::string& md5,
-               const GetFileFromCacheCallback& callback);
+  // Must be called on the UI thread.
+  void GetFileOnUIThread(const std::string& resource_id,
+                         const std::string& md5,
+                         const GetFileFromCacheCallback& callback);
 
   // Stores |source_path| as a cache of the remote content of the file
   // identified by |resource_id| and |md5|.
   // |callback| must not be null.
-  void Store(const std::string& resource_id,
-             const std::string& md5,
-             const base::FilePath& source_path,
-             FileOperationType file_operation_type,
-             const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void StoreOnUIThread(const std::string& resource_id,
+                       const std::string& md5,
+                       const base::FilePath& source_path,
+                       FileOperationType file_operation_type,
+                       const FileOperationCallback& callback);
 
   // Stores |source_path| to the cache and mark it as dirty, i.e., needs to be
   // uploaded to the remove server for syncing.
   // |callback| must not be null.
-  void StoreLocallyModified(const std::string& resource_id,
-                            const std::string& md5,
-                            const base::FilePath& source_path,
-                            FileOperationType file_operation_type,
-                            const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void StoreLocallyModifiedOnUIThread(const std::string& resource_id,
+                                      const std::string& md5,
+                                      const base::FilePath& source_path,
+                                      FileOperationType file_operation_type,
+                                      const FileOperationCallback& callback);
 
   // Modifies cache state, which involves the following:
   // - moves |source_path| to |dest_path| in persistent dir if
   //   file is not dirty
   // - creates symlink in pinned dir that references downloaded or locally
   //   modified file
   // |callback| must not be null.
-  void Pin(const std::string& resource_id,
-           const std::string& md5,
-           const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void PinOnUIThread(const std::string& resource_id,
+                     const std::string& md5,
+                     const FileOperationCallback& callback);
 
   // Modifies cache state, which involves the following:
   // - moves |source_path| to |dest_path| in tmp dir if file is not dirty
   // - deletes symlink from pinned dir
   // |callback| must not be null.
-  void Unpin(const std::string& resource_id,
-             const std::string& md5,
-             const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void UnpinOnUIThread(const std::string& resource_id,
+                       const std::string& md5,
+                       const FileOperationCallback& callback);
 
   // Sets the state of the cache entry corresponding to |resource_id| and |md5|
   // as mounted.
   // |callback| must not be null.
-  void MarkAsMounted(const std::string& resource_id,
-                     const std::string& md5,
-                     const GetFileFromCacheCallback& callback);
+  // Must be called on the UI thread.
+  void MarkAsMountedOnUIThread(const std::string& resource_id,
+                               const std::string& md5,
+                               const GetFileFromCacheCallback& callback);
 
   // Set the state of the cache entry corresponding to file_path as unmounted.
   // |callback| must not be null.
-  void MarkAsUnmounted(const base::FilePath& file_path,
-                       const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void MarkAsUnmountedOnUIThread(const base::FilePath& file_path,
+                                 const FileOperationCallback& callback);
 
   // Modifies cache state, 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
   // |callback| must not be null.
-  void MarkDirty(const std::string& resource_id,
-                 const std::string& md5,
-                 const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void MarkDirtyOnUIThread(const std::string& resource_id,
+                           const std::string& md5,
+                           const FileOperationCallback& callback);
 
   // Modifies cache state, i.e. creates symlink in outgoing
   // dir to reference dirty file in persistent dir.
   // |callback| must not be null.
-  void CommitDirty(const std::string& resource_id,
-                   const std::string& md5,
-                   const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void CommitDirtyOnUIThread(const std::string& resource_id,
+                             const std::string& md5,
+                             const FileOperationCallback& callback);
 
   // Modifies cache state, which involves the following:
   // - moves |source_path| to |dest_path| in persistent dir if
   //   file is pinned or tmp dir otherwise, where |source_path| has .local
   //   extension and |dest_path| has .<md5> extension
   // - deletes symlink in outgoing dir
   // - if file is pinned, updates symlink in pinned dir to reference
   //   |dest_path|
   // |callback| must not be null.
-  void ClearDirty(const std::string& resource_id,
-                  const std::string& md5,
-                  const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void ClearDirtyOnUIThread(const std::string& resource_id,
+                            const std::string& md5,
+                            const FileOperationCallback& callback);
 
   // Does the following:
   // - remove all delete stale cache versions corresponding to |resource_id| in
   //   persistent, tmp and pinned directories
   // - remove entry corresponding to |resource_id| from cache map.
   // |callback| must not be null.
-  void Remove(const std::string& resource_id,
-              const FileOperationCallback& callback);
+  // Must be called on the UI thread.
+  void RemoveOnUIThread(const std::string& resource_id,
+                        const FileOperationCallback& callback);
 
   // Does the following:
   // - remove all the files in the cache directory.
   // - re-create the |metadata_| instance.
   // |callback| must not be null.
-  void ClearAll(const InitializeCacheCallback& callback);
+  // Must be called on the UI thread.
+  void ClearAllOnUIThread(const InitializeCacheCallback& callback);
 
   // Utility method to call Initialize on UI thread. |callback| is called on
   // UI thread when the initialization is complete.
   // |callback| must not be null.
   void RequestInitialize(const InitializeCacheCallback& callback);
 
   // Utility method to call InitializeForTesting on UI thread.
   void RequestInitializeForTesting();
 
   // Destroys this cache. This function posts a task to the blocking task
   // runner to safely delete the object.
+  // Must be called on the UI thread.
   void Destroy();
 
   // Returns file paths for all the cache sub directories under
   // |cache_root_path|.
   static std::vector<base::FilePath> GetCachePaths(
       const base::FilePath& cache_root_path);
 
   // Creates cache directory and its sub-directories if they don't exist.
   // TODO(glotov): take care of this when the setup and cleanup part is
   // landed, noting that these directories need to be created for development
@@ skipping 10 matching lines @@
 
   typedef std::pair<FileError, base::FilePath> GetFileResult;
 
   // Enum defining origin of a cached file.
   enum CachedFileOrigin {
     CACHED_FILE_FROM_SERVER = 0,
     CACHED_FILE_LOCALLY_MODIFIED,
     CACHED_FILE_MOUNTED,
   };
 
   virtual ~FileCache();

[hidehiko, 2013/05/09 06:41:04]

off topic nit: s/virtual//

[hashimoto, 2013/05/09 07:13:44]

Done.

 
   // Returns absolute path of the file if it were cached or to be cached.
   //
   // Can be called on any thread.
   base::FilePath GetCacheFilePath(const std::string& resource_id,
                                   const std::string& md5,
                                   CacheSubDirectoryType sub_dir_type,
                                   CachedFileOrigin file_origin) const;
 
 
   // Checks whether the current thread is on the right sequenced worker pool
   // with the right sequence ID. If not, DCHECK will fail.
   void AssertOnSequencedWorkerPool();
 
   // Initializes the cache. Returns true on success.
   bool InitializeOnBlockingPool();
 
   // Initializes the cache with in-memory cache for testing.
   // The in-memory cache is used since it's faster than the db.
   void InitializeOnBlockingPoolForTesting();
 
   // Destroys the cache on the blocking pool.
   void DestroyOnBlockingPool();
 
   // Gets the cache entry by the given resource ID and MD5.
-  // See also GetCacheEntry().
-  bool GetCacheEntryOnBlockingPool(const std::string& resource_id,
-                                   const std::string& md5,
-                                   FileCacheEntry* entry);
+  // See also GetCacheEntryOnUIThread().
+  bool GetCacheEntry(const std::string& resource_id,
+                     const std::string& md5,
+                     FileCacheEntry* entry);
 
-  // Used to implement Iterate().
-  void IterateOnBlockingPool(const CacheIterateCallback& iteration_callback);
+  // Used to implement IterateOnUIThread().
+  void Iterate(const CacheIterateCallback& iteration_callback);
 
-  // Used to implement FreeDiskSpaceIfNeededFor().
-  bool FreeDiskSpaceOnBlockingPoolIfNeededFor(int64 num_bytes);
+  // Used to implement FreeDiskSpaceIfNeededForOnUIThread().
+  bool FreeDiskSpaceIfNeededFor(int64 num_bytes);
 
-  // Used to implement GetFile.
-  scoped_ptr<GetFileResult> GetFileOnBlockingPool(
-      const std::string& resource_id,
-      const std::string& md5);
-
-  // Used to implement Store.
-  FileError StoreOnBlockingPool(const std::string& resource_id,
-                                const std::string& md5,
-                                const base::FilePath& source_path,
-                                FileOperationType file_operation_type,
-                                CachedFileOrigin origin);
-
-  // Used to implement Pin.
-  FileError PinOnBlockingPool(const std::string& resource_id,
-                              const std::string& md5);
-
-  // Used to implement Unpin.
-  FileError UnpinOnBlockingPool(const std::string& resource_id,
-                                const std::string& md5);
-
-  // Used to implement MarkAsMounted.
-  scoped_ptr<GetFileResult> MarkAsMountedOnBlockingPool(
-      const std::string& resource_id,
-      const std::string& md5);
-
-  // Used to implement MarkAsUnmounted.
-  FileError MarkAsUnmountedOnBlockingPool(const base::FilePath& file_path);
-
-  // Used to implement MarkDirty.
-  FileError MarkDirtyOnBlockingPool(const std::string& resource_id,
+  // Used to implement GetFileOnUIThread.
+  scoped_ptr<GetFileResult> GetFile(const std::string& resource_id,
                                     const std::string& md5);
 
-  // Used to implement CommitDirty.
-  FileError CommitDirtyOnBlockingPool(const std::string& resource_id,
-                                      const std::string& md5);
+  // Used to implement StoreOnUIThread.
+  FileError Store(const std::string& resource_id,
+                  const std::string& md5,
+                  const base::FilePath& source_path,
+                  FileOperationType file_operation_type,
+                  CachedFileOrigin origin);
 
-  // Used to implement ClearDirty.
-  FileError ClearDirtyOnBlockingPool(const std::string& resource_id,
-                                     const std::string& md5);
+  // Used to implement PinOnUIThread.
+  FileError Pin(const std::string& resource_id,
+                const std::string& md5);
 
-  // Used to implement Remove.
-  FileError RemoveOnBlockingPool(const std::string& resource_id);
+  // Used to implement UnpinOnUIThread.
+  FileError Unpin(const std::string& resource_id,
+                  const std::string& md5);
 
-  // Used to implement ClearAll.
-  bool ClearAllOnBlockingPool();
+  // Used to implement MarkAsMountedOnUIThread.
+  scoped_ptr<GetFileResult> MarkAsMounted(const std::string& resource_id,
+                                          const std::string& md5);
+
+  // Used to implement MarkAsUnmountedOnUIThread.
+  FileError MarkAsUnmounted(const base::FilePath& file_path);
+
+  // Used to implement MarkDirtyOnUIThread.
+  FileError MarkDirty(const std::string& resource_id,
+                      const std::string& md5);
+
+  // Used to implement CommitDirtyOnUIThread.
+  FileError CommitDirty(const std::string& resource_id,
+                        const std::string& md5);
+
+  // Used to implement ClearDirtyOnUIThread.
+  FileError ClearDirty(const std::string& resource_id,
+                       const std::string& md5);
+
+  // Used to implement RemoveOnUIThread.
+  FileError Remove(const std::string& resource_id);
+
+  // Used to implement ClearAllOnUIThread.
+  bool ClearAll();
 
   // Runs callback and notifies the observers when file is pinned.
   void OnPinned(const std::string& resource_id,
                 const std::string& md5,
                 const FileOperationCallback& callback,
                 FileError error);
 
   // Runs callback and notifies the observers when file is unpinned.
   void OnUnpinned(const std::string& resource_id,
                   const std::string& md5,
@@ skipping 35 matching lines @@
 // this value.
 //
 // Copied from cryptohome/homedirs.h.
 // TODO(satorux): Share the constant.
 const int64 kMinFreeSpace = 512 * 1LL << 20;
 
 }  // namespace internal
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILE_CACHE_H_