drive: Remove FileCacheObserver::OnCacheCommitted

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/files/file_enumerator.h"
@@ skipping 467 matching lines @@
                  base::Unretained(this),
                  resource_id, md5, source_path, file_operation_type),
       callback);
 }
 
 FileError FileCache::Store(const std::string& resource_id,
                            const std::string& md5,
                            const base::FilePath& source_path,
                            FileOperationType file_operation_type) {
   AssertOnSequencedWorkerPool();
-  return StoreInternal(resource_id, md5, source_path, file_operation_type,
-                       CACHED_FILE_FROM_SERVER);
-}
-
-void FileCache::StoreLocallyModifiedOnUIThread(
-    const std::string& resource_id,
-    const std::string& md5,
-    const base::FilePath& source_path,
-    FileOperationType file_operation_type,
-    const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
-      FROM_HERE,
-      base::Bind(&FileCache::StoreInternal,
-                 base::Unretained(this),
-                 resource_id, md5, source_path, file_operation_type,
-                 CACHED_FILE_LOCALLY_MODIFIED),
-      base::Bind(&FileCache::OnCommitDirty,
-                 weak_ptr_factory_.GetWeakPtr(), resource_id, callback));
+  return StoreInternal(resource_id, md5, source_path, file_operation_type);
 }
 
 void FileCache::PinOnUIThread(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_,
@@ skipping 206 matching lines @@
     return FILE_ERROR_FAILED;
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_dirty(true);
   cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
-void FileCache::CommitDirtyOnUIThread(const std::string& resource_id,
-                                      const std::string& md5,
-                                      const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  // TODO(hashimoto): Move logic around OnCommitDirty to FileSystem and remove
-  // this method.
-  base::MessageLoopProxy::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&FileCache::OnCommitDirty,
-                 weak_ptr_factory_.GetWeakPtr(), resource_id, callback,
-                 FILE_ERROR_OK));
-}
-
 FileError FileCache::ClearDirty(const std::string& resource_id,
                                 const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
   FileCacheEntry cache_entry;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
@@ skipping 174 matching lines @@
 }
 
 void FileCache::DestroyOnBlockingPool() {
   AssertOnSequencedWorkerPool();
   delete this;
 }
 
 FileError FileCache::StoreInternal(const std::string& resource_id,
                                    const std::string& md5,
                                    const base::FilePath& source_path,
-                                   FileOperationType file_operation_type,
-                                   CachedFileOrigin origin) {
+                                   FileOperationType file_operation_type) {
   AssertOnSequencedWorkerPool();
 
   int64 file_size = 0;
   if (file_operation_type == FILE_OPERATION_COPY) {
     if (!file_util::GetFileSize(source_path, &file_size)) {
       LOG(WARNING) << "Couldn't get file size for: " << source_path.value();
       return FILE_ERROR_FAILED;
     }
   }
   if (!FreeDiskSpaceIfNeededFor(file_size))
     return FILE_ERROR_NO_SPACE;
 
   FileCacheEntry cache_entry;
   GetCacheEntry(resource_id, std::string(), &cache_entry);
 
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
-  if (origin == CACHED_FILE_FROM_SERVER) {
-    // If file is dirty or mounted, return error.
-    if (cache_entry.is_dirty() || cache_entry.is_mounted()) {
-      LOG(WARNING) << "Can't store a file to replace a "
-                   << (cache_entry.is_dirty() ? "dirty" : "mounted")
-                   << " file: res_id=" << resource_id
-                   << ", md5=" << md5;
-      return FILE_ERROR_IN_USE;
-    }
-
-    // If file was previously pinned, store it in persistent dir.
-    if (cache_entry.is_pinned())
-      sub_dir_type = CACHE_TYPE_PERSISTENT;
-  } else {
-    sub_dir_type = CACHE_TYPE_PERSISTENT;
+  // If file is dirty or mounted, return error.
+  if (cache_entry.is_dirty() || cache_entry.is_mounted()) {
+    LOG(WARNING) << "Can't store a file to replace a "
+                 << (cache_entry.is_dirty() ? "dirty" : "mounted")
+                 << " file: res_id=" << resource_id
+                 << ", md5=" << md5;
+    return FILE_ERROR_IN_USE;
   }
 
+  // If file was previously pinned, store it in persistent dir.
+  if (cache_entry.is_pinned())
+    sub_dir_type = CACHE_TYPE_PERSISTENT;
+
   base::FilePath dest_path = GetCacheFilePath(resource_id, md5, sub_dir_type,
-                                              origin);
+                                              CACHED_FILE_FROM_SERVER);
   bool success = false;
   switch (file_operation_type) {
     case FILE_OPERATION_MOVE:
       success = MoveFile(source_path, dest_path);
       break;
     case FILE_OPERATION_COPY:
       success = CopyFile(source_path, dest_path);
       break;
     default:
       NOTREACHED();
@@ skipping 19 matching lines @@
   }
 
   // Delete files that match |stale_filenames_pattern| except for |dest_path|.
   DeleteFilesSelectively(stale_filenames_pattern, dest_path);
 
   if (success) {
     // Now that file operations have completed, update metadata.
     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);
+    cache_entry.set_is_dirty(false);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
 
   return success ? FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
 FileError FileCache::MarkAsMounted(const std::string& resource_id,
                                    base::FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(cache_file_path);
@@ skipping 128 matching lines @@
 
   // Now the file is moved from "persistent" to "tmp" directory.
   // It's a chance to free up space if needed.
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&FileCache::FreeDiskSpaceIfNeededFor),
           base::Unretained(this), 0));
 }
 
-void FileCache::OnCommitDirty(const std::string& resource_id,
-                              const FileOperationCallback& callback,
-                              FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  callback.Run(error);
-
-  if (error == FILE_ERROR_OK)
-    FOR_EACH_OBSERVER(FileCacheObserver,
-                      observers_,
-                      OnCacheCommitted(resource_id));
-}
-
 bool FileCache::HasEnoughSpaceFor(int64 num_bytes,
                                   const base::FilePath& path) {
   int64 free_space = 0;
   if (free_disk_space_getter_)
     free_space = free_disk_space_getter_->AmountOfFreeDiskSpace();
   else
     free_space = base::SysInfo::AmountOfFreeDiskSpace(path);
 
   // Subtract this as if this portion does not exist.
   free_space -= kMinFreeSpace;
@@ skipping 34 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