drive: Remove MD5 argument from FileCache::MarkDirty

BUG=248424
TEST=unit_tests

Review URL: https://chromiumcodereview.appspot.com/18948004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@213379 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/chromeos/drive/file_cache.cc

@@ -390,7 +390,6 @@ void FileCache::MarkAsUnmountedOnUIThread(
 }
 
 void FileCache::MarkDirtyOnUIThread(const std::string& resource_id,
-                                    const std::string& md5,
                                     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
@@ -398,28 +397,20 @@ void FileCache::MarkDirtyOnUIThread(const std::string& resource_id,
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
-      base::Bind(
-          &FileCache::MarkDirty, base::Unretained(this), resource_id, md5),
+      base::Bind(&FileCache::MarkDirty, base::Unretained(this), resource_id),
       callback);
 }
 
-FileError FileCache::MarkDirty(const std::string& resource_id,
-                               const std::string& md5) {
+FileError FileCache::MarkDirty(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
-  // If file has already been marked dirty in previous instance of chrome, we
-  // would have lost the md5 info during cache initialization, because the file
-  // would have been renamed to .local extension.
-  // So, search for entry in cache without comparing md5.
-
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
   FileCacheEntry cache_entry;
-  if (!GetCacheEntry(resource_id, md5, &cache_entry) ||
+  if (!storage_->GetCacheEntry(resource_id, &cache_entry) ||
       !cache_entry.is_present()) {
-    LOG(WARNING) << "Can't mark dirty a file that wasn't cached: res_id="
-                 << resource_id
-                 << ", md5=" << md5;
+    LOG(WARNING) << "Can't mark dirty a file that wasn't cached: "
+                 << resource_id;
     return FILE_ERROR_NOT_FOUND;
   }
 

chrome/browser/chromeos/drive/file_cache.h

@@ -200,12 +200,10 @@ class FileCache {
   // |callback| must not be null.
   // Must be called on the UI thread.
   void MarkDirtyOnUIThread(const std::string& resource_id,
-                           const std::string& md5,
                            const FileOperationCallback& callback);
 
   // Marks the specified entry dirty.
-  FileError MarkDirty(const std::string& resource_id,
-                      const std::string& md5);
+  FileError MarkDirty(const std::string& resource_id);
 
   // Clears dirty state of the specified entry.
   FileError ClearDirty(const std::string& resource_id,

chrome/browser/chromeos/drive/file_cache_unittest.cc

@@ -200,7 +200,6 @@ class FileCacheTestOnUIThread : public testing::Test {
   }
 
   void TestMarkDirty(const std::string& resource_id,
-                     const std::string& md5,
                      FileError expected_error,
                      int expected_cache_state) {
     expected_error_ = expected_error;
@@ -208,17 +207,17 @@ class FileCacheTestOnUIThread : public testing::Test {
 
     FileError error = FILE_ERROR_OK;
     cache_->MarkDirtyOnUIThread(
-        resource_id, md5,
+        resource_id,
         google_apis::test_util::CreateCopyResultCallback(&error));
     test_util::RunBlockingPoolTask();
 
-    VerifyCacheFileState(error, resource_id, md5);
+    VerifyCacheFileState(error, resource_id, std::string());
 
     // Verify filename.
     if (error == FILE_ERROR_OK) {
       base::FilePath cache_file_path;
       cache_->GetFileOnUIThread(
-          resource_id, md5,
+          resource_id, std::string(),
           google_apis::test_util::CreateCopyResultCallback(
               &error, &cache_file_path));
       test_util::RunBlockingPoolTask();
@@ -554,7 +553,7 @@ TEST_F(FileCacheTestOnUIThread, DirtyCacheSimple) {
                    FILE_ERROR_OK, TEST_CACHE_STATE_PRESENT);
 
   // Mark the file dirty.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Clear dirty state of the file.
@@ -572,7 +571,7 @@ TEST_F(FileCacheTestOnUIThread, DirtyCachePinned) {
           TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_PINNED);
 
   // Mark the file dirty.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT |
                 TEST_CACHE_STATE_DIRTY |
                 TEST_CACHE_STATE_PINNED);
@@ -589,7 +588,7 @@ TEST_F(FileCacheTestOnUIThread, PinAndUnpinDirtyCache) {
   // First store a file to cache and mark it as dirty.
   TestStoreToCache(resource_id, md5, dummy_file_path_,
                    FILE_ERROR_OK, TEST_CACHE_STATE_PRESENT);
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Verifies dirty file exists.
@@ -628,11 +627,11 @@ TEST_F(FileCacheTestOnUIThread, DirtyCacheRepetitive) {
                    FILE_ERROR_OK, TEST_CACHE_STATE_PRESENT);
 
   // Mark the file dirty.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Again, mark the file dirty.  Nothing should change.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
 
   // Clear dirty state of the file.
@@ -648,7 +647,7 @@ TEST_F(FileCacheTestOnUIThread, DirtyCacheInvalid) {
   std::string md5("abcdef0123456789");
 
   // Mark a non-existent file dirty.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_NOT_FOUND, TEST_CACHE_STATE_NONE);
+  TestMarkDirty(resource_id, FILE_ERROR_NOT_FOUND, TEST_CACHE_STATE_NONE);
 
   // Clear dirty state of a non-existent file.
   TestClearDirty(resource_id, md5, FILE_ERROR_NOT_FOUND, TEST_CACHE_STATE_NONE);
@@ -663,7 +662,7 @@ TEST_F(FileCacheTestOnUIThread, DirtyCacheInvalid) {
 
   // Mark an existing file dirty, then store a new file to the same resource id
   // but different md5, which should fail.
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_DIRTY);
   md5 = "new_md5";
   TestStoreToCache(resource_id, md5, dummy_file_path_,
@@ -680,7 +679,7 @@ TEST_F(FileCacheTestOnUIThread, RemoveFromDirtyCache) {
                    FILE_ERROR_OK, TEST_CACHE_STATE_PRESENT);
   TestPin(resource_id, FILE_ERROR_OK,
           TEST_CACHE_STATE_PRESENT | TEST_CACHE_STATE_PINNED);
-  TestMarkDirty(resource_id, md5, FILE_ERROR_OK,
+  TestMarkDirty(resource_id, FILE_ERROR_OK,
                 TEST_CACHE_STATE_PRESENT |
                 TEST_CACHE_STATE_PINNED |
                 TEST_CACHE_STATE_DIRTY);

chrome/browser/chromeos/drive/file_system/copy_operation.cc

@@ -46,7 +46,7 @@ FileError StoreAndMarkDirty(internal::FileCache* cache,
                                  internal::FileCache::FILE_OPERATION_COPY);
   if (error != FILE_ERROR_OK)
     return error;
-  return cache->MarkDirty(resource_id, md5);
+  return cache->MarkDirty(resource_id);
 }
 
 }  // namespace

chrome/browser/chromeos/drive/file_system/download_operation_unittest.cc

@@ -414,7 +414,6 @@ TEST_F(DownloadOperationTest, EnsureFileDownloadedByPath_DirtyCache) {
   EXPECT_EQ(FILE_ERROR_OK, error);
   cache()->MarkDirtyOnUIThread(
       src_entry.resource_id(),
-      src_entry.file_specific_info().md5(),
       google_apis::test_util::CreateCopyResultCallback(&error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);

chrome/browser/chromeos/drive/file_system/open_file_operation.cc

@@ -28,7 +28,7 @@ FileError UpdateFileLocalState(internal::FileCache* cache,
                                const std::string& resource_id,
                                const std::string& md5,
                                base::FilePath* local_file_path) {
-  FileError error = cache->MarkDirty(resource_id, md5);
+  FileError error = cache->MarkDirty(resource_id);
   if (error != FILE_ERROR_OK)
     return error;
 

chrome/browser/chromeos/drive/file_system/truncate_operation.cc

@@ -48,12 +48,11 @@ class ScopedPlatformFileCloser {
 // then marks the resource is dirty on |cache|.
 FileError TruncateOnBlockingPool(internal::FileCache* cache,
                                  const std::string& resource_id,
-                                 const std::string& md5,
                                  const base::FilePath& local_cache_path,
                                  int64 length) {
   DCHECK(cache);
 
-  FileError error = cache->MarkDirty(resource_id, md5);
+  FileError error = cache->MarkDirty(resource_id);
   if (error != FILE_ERROR_OK)
     return error;
 
@@ -149,7 +148,7 @@ void TruncateOperation::TruncateAfterEnsureFileDownloadedByPath(
       FROM_HERE,
       base::Bind(&TruncateOnBlockingPool,
                  base::Unretained(cache_),
-                 entry->resource_id(), entry->file_specific_info().md5(),
+                 entry->resource_id(),
                  local_file_path, length),
       base::Bind(
           &TruncateOperation::TruncateAfterTruncateOnBlockingPool,

chrome/browser/chromeos/drive/file_system/update_operation_unittest.cc

@@ -57,7 +57,7 @@ TEST_F(UpdateOperationTest, UpdateFileByResourceId_PersistentFile) {
   // Add the dirty bit.
   error = FILE_ERROR_FAILED;
   cache()->MarkDirtyOnUIThread(
-      kResourceId, kMd5,
+      kResourceId,
       google_apis::test_util::CreateCopyResultCallback(&error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
@@ -132,7 +132,7 @@ TEST_F(UpdateOperationTest, UpdateFileByResourceId_Md5) {
   // Add the dirty bit.
   error = FILE_ERROR_FAILED;
   cache()->MarkDirtyOnUIThread(
-      kResourceId, kMd5,
+      kResourceId,
       google_apis::test_util::CreateCopyResultCallback(&error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
@@ -178,7 +178,7 @@ TEST_F(UpdateOperationTest, UpdateFileByResourceId_Md5) {
   // Again mark the cache file dirty.
   error = FILE_ERROR_FAILED;
   cache()->MarkDirtyOnUIThread(
-      kResourceId, server_entry->file_md5(),
+      kResourceId,
       google_apis::test_util::CreateCopyResultCallback(&error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);

chrome/browser/chromeos/drive/remove_stale_cache_files_unittest.cc

@@ -94,7 +94,7 @@ TEST_F(RemoveStaleCacheFilesTest, DirtyCacheFiles) {
   EXPECT_EQ(FILE_ERROR_OK,
             cache_->Store(resource_id_1, md5_1, dummy_file,
                           FileCache::FILE_OPERATION_COPY));
-  EXPECT_EQ(FILE_ERROR_OK, cache_->MarkDirty(resource_id_1, md5_1));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->MarkDirty(resource_id_1));
 
   // Dirty and mismatching-MD5 entry.
   std::string resource_id_2("file:2");
@@ -103,7 +103,7 @@ TEST_F(RemoveStaleCacheFilesTest, DirtyCacheFiles) {
   EXPECT_EQ(FILE_ERROR_OK,
             cache_->Store(resource_id_2, md5_2_cache, dummy_file,
                           FileCache::FILE_OPERATION_COPY));
-  EXPECT_EQ(FILE_ERROR_OK, cache_->MarkDirty(resource_id_2, md5_2_cache));
+  EXPECT_EQ(FILE_ERROR_OK, cache_->MarkDirty(resource_id_2));
 
   ResourceEntry entry;
   entry.set_resource_id(resource_id_2);

chrome/browser/chromeos/drive/sync_client_unittest.cc

@@ -178,8 +178,7 @@ class SyncClientTest : public testing::Test {
               cache_->Store(resource_ids_["dirty"], md5_dirty,
                             temp_file, FileCache::FILE_OPERATION_COPY));
     EXPECT_EQ(FILE_ERROR_OK, cache_->Pin(resource_ids_["dirty"]));
-    EXPECT_EQ(FILE_ERROR_OK,
-              cache_->MarkDirty(resource_ids_["dirty"], md5_dirty));
+    EXPECT_EQ(FILE_ERROR_OK, cache_->MarkDirty(resource_ids_["dirty"]));
 
     // Load data from the service to the metadata.
     FileError error = FILE_ERROR_FAILED;

chrome/browser/chromeos/drive/test_util.cc

@@ -158,7 +158,6 @@ bool PrepareTestCacheResources(
       FileError error = FILE_ERROR_OK;
       cache->MarkDirtyOnUIThread(
           resources[i].resource_id,
-          resources[i].md5,
           google_apis::test_util::CreateCopyResultCallback(&error));
       test_util::RunBlockingPoolTask();
       if (error != FILE_ERROR_OK)