drive: Move temporary file removal responsiblity to FileCache

chrome/browser/chromeos/drive/file_cache.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/drive/file_cache.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 280 matching lines @@
 
 bool FileCache::FreeDiskSpaceIfNeededFor(int64 num_bytes) {
   AssertOnSequencedWorkerPool();
 
   // Do nothing and return if we have enough space.
   if (HasEnoughSpaceFor(num_bytes, cache_root_path_))
     return true;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
+
   // First remove temporary files from the metadata.
-  metadata_->RemoveTemporaryFiles();
+  scoped_ptr<FileCacheMetadata::Iterator> it = metadata_->GetIterator();
+  for (; !it->IsAtEnd(); it->Advance()) {
+    if (!it->GetValue().is_persistent())
+      metadata_->RemoveCacheEntry(it->GetKey());
+  }
+  DCHECK(!it->HasError());
+
   // Then remove all files under "tmp" directory.
   RemoveAllFiles(GetCacheDirectoryPath(CACHE_TYPE_TMP));
 
   // Check the disk space again.
   return HasEnoughSpaceFor(num_bytes, cache_root_path_);
 }
 
 void FileCache::GetFileOnUIThread(const std::string& resource_id,
                                   const std::string& md5,
                                   const GetFileFromCacheCallback& callback) {
@@ skipping 91 matching lines @@
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&FileCache::Pin,
                  base::Unretained(this), resource_id, md5),
       base::Bind(&FileCache::OnPinned,
                  weak_ptr_factory_.GetWeakPtr(), resource_id, md5, callback));
 }
 
+FileError FileCache::Pin(const std::string& resource_id,
+                         const std::string& md5) {
+  AssertOnSequencedWorkerPool();
+
+  bool is_persistent = true;
+  FileCacheEntry cache_entry;
+  if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
+    // The file will be first downloaded in 'tmp', then moved to 'persistent'.
+    is_persistent = false;
+  } else {  // File exists in cache, determines destination path.
+    // Determine source and destination paths.
+
+    // If file is dirty or mounted, don't move it.
+    if (!cache_entry.is_dirty() && !cache_entry.is_mounted()) {
+      // If file was pinned before but actual file blob doesn't exist in cache:
+      // - don't need to move the file.
+      if (!cache_entry.is_present()) {
+        DCHECK(cache_entry.is_pinned());
+        return FILE_ERROR_OK;
+      }
+      // File exists, move it to persistent dir.
+      // Gets the current path of the file in cache.
+      base::FilePath source_path = GetCacheFilePath(
+          resource_id,
+          md5,
+          GetSubDirectoryType(cache_entry),
+          CACHED_FILE_FROM_SERVER);
+      base::FilePath dest_path = GetCacheFilePath(resource_id,
+                                                  md5,
+                                                  CACHE_TYPE_PERSISTENT,
+                                                  CACHED_FILE_FROM_SERVER);
+      if (!MoveFile(source_path, dest_path))
+        return FILE_ERROR_FAILED;
+    }
+  }
+
+  // Now that file operations have completed, update metadata.
+  cache_entry.set_md5(md5);
+  cache_entry.set_is_pinned(true);
+  cache_entry.set_is_persistent(is_persistent);
+  metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
+  return FILE_ERROR_OK;
+}
+
 void FileCache::UnpinOnUIThread(const std::string& resource_id,
                                 const std::string& md5,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&FileCache::Unpin,
@@ skipping 367 matching lines @@
     cache_entry.set_md5(md5);
     cache_entry.set_is_present(true);
     cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
     cache_entry.set_is_dirty(origin == CACHED_FILE_LOCALLY_MODIFIED);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
 
   return success ? FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-FileError FileCache::Pin(const std::string& resource_id,
-                         const std::string& md5) {
-  AssertOnSequencedWorkerPool();
-
-  bool is_persistent = true;
-  FileCacheEntry cache_entry;
-  if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
-    // The file will be first downloaded in 'tmp', then moved to 'persistent'.
-    is_persistent = false;
-  } else {  // File exists in cache, determines destination path.
-    // Determine source and destination paths.
-
-    // If file is dirty or mounted, don't move it.
-    if (!cache_entry.is_dirty() && !cache_entry.is_mounted()) {
-      // If file was pinned before but actual file blob doesn't exist in cache:
-      // - don't need to move the file.
-      if (!cache_entry.is_present()) {
-        DCHECK(cache_entry.is_pinned());
-        return FILE_ERROR_OK;
-      }
-      // File exists, move it to persistent dir.
-      // Gets the current path of the file in cache.
-      base::FilePath source_path = GetCacheFilePath(
-          resource_id,
-          md5,
-          GetSubDirectoryType(cache_entry),
-          CACHED_FILE_FROM_SERVER);
-      base::FilePath dest_path = GetCacheFilePath(resource_id,
-                                                  md5,
-                                                  CACHE_TYPE_PERSISTENT,
-                                                  CACHED_FILE_FROM_SERVER);
-      if (!MoveFile(source_path, dest_path))
-        return FILE_ERROR_FAILED;
-    }
-  }
-
-  // Now that file operations have completed, update metadata.
-  cache_entry.set_md5(md5);
-  cache_entry.set_is_pinned(true);
-  cache_entry.set_is_persistent(is_persistent);
-  metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
-  return FILE_ERROR_OK;
-}
-
-
 FileError FileCache::MarkAsMounted(const std::string& resource_id,
                                    const std::string& md5,
                                    base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
 
   // Get cache entry associated with the resource_id and md5
   FileCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry))
     return FILE_ERROR_NOT_FOUND;
@@ skipping 244 matching lines @@
 }
 
 // static
 FileCache::CacheSubDirectoryType FileCache::GetSubDirectoryType(
     const FileCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 }  // namespace internal
 }  // namespace drive