drive: Remove FileCacheObserver::OnCacheCommitted

chrome/browser/chromeos/drive/file_system_unittest.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_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/fake_free_disk_space_getter.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/mock_directory_change_observer.h"
 #include "chrome/browser/chromeos/drive/mock_file_cache_observer.h"
+#include "chrome/browser/chromeos/drive/sync_client.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/fake_drive_service.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 78 matching lines @@
 
     file_system_.reset(new FileSystem(profile_.get(),
                                       cache_.get(),
                                       fake_drive_service_.get(),
                                       scheduler_.get(),
                                       resource_metadata_.get(),
                                       blocking_task_runner_));
     file_system_->AddObserver(mock_directory_observer_.get());
     file_system_->Initialize();
 
+    // Disable delaying so that the sync starts immediately.
+    file_system_->sync_client_for_testing()->set_delay_for_testing(
+        base::TimeDelta::FromSeconds(0));
+
     FileError error = FILE_ERROR_FAILED;
     resource_metadata_->Initialize(
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     ASSERT_EQ(FILE_ERROR_OK, error);
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
     file_system_.reset();
@@ skipping 524 matching lines @@
       true,  // is_exclusive
       false,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It should fail because is_exclusive is set to true.
   EXPECT_EQ(FILE_ERROR_EXISTS, error);
 }
 
 TEST_F(FileSystemTest, PinAndUnpin) {
+  // Pinned file gets synced and it results in entry state changes.
+  EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(AtLeast(1));
+
   ASSERT_TRUE(LoadFullResourceList());
 
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Get the file info.
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(file_path));
   ASSERT_TRUE(entry);
 
   // Pin the file.
   FileError error = FILE_ERROR_FAILED;
@@ skipping 42 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 }
 
 TEST_F(FileSystemTest, OpenAndCloseFile) {
   ASSERT_TRUE(LoadFullResourceList());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(AtLeast(1));
 
   const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry(GetResourceEntryByPathSync(kFileInRoot));
   const std::string& file_resource_id = entry->resource_id();
   const std::string& md5 = entry->file_specific_info().md5();
 
-  // A dirty file is created on close.
-  EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(file_resource_id))
-      .Times(1);
-
   // Open kFileInRoot ("drive/root/File 1.txt").
   FileError error = FILE_ERROR_FAILED;
   base::FilePath file_path;
   file_system_->OpenFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   const base::FilePath opened_file_path = file_path;
 
   // Verify that the file was properly opened.
@@ skipping 22 matching lines @@
   EXPECT_TRUE(cache_entry.is_persistent());
 
   base::FilePath cache_file_path;
   cache_->GetFileOnUIThread(file_resource_id, md5,
                             google_apis::test_util::CreateCopyResultCallback(
                                 &error, &cache_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_EQ(cache_file_path, opened_file_path);
 
+  // Write a new content.
+  const std::string kNewContent = kExpectedContent + kExpectedContent;
+  EXPECT_TRUE(google_apis::test_util::WriteStringToFile(cache_file_path,
+                                                        kNewContent));
+
   // Close kFileInRoot ("drive/root/File 1.txt").
   file_system_->CloseFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // Verify that the file was properly closed.
   EXPECT_EQ(FILE_ERROR_OK, error);
 
-  // Verify that the cache state was changed as expected.
-  EXPECT_TRUE(GetCacheEntryFromOriginThread(file_resource_id, md5,
-                                            &cache_entry));
-  EXPECT_TRUE(cache_entry.is_present());
-  EXPECT_TRUE(cache_entry.is_dirty());
-  EXPECT_TRUE(cache_entry.is_persistent());
+  // Verify that the file was synced as expected.
+  google_apis::GDataErrorCode gdata_error = google_apis::GDATA_FILE_ERROR;
+  scoped_ptr<google_apis::ResourceEntry> gdata_entry;
+  fake_drive_service_->GetResourceEntry(
+      file_resource_id,
+      google_apis::test_util::CreateCopyResultCallback(
+          &gdata_error, &gdata_entry));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(gdata_error, google_apis::HTTP_SUCCESS);
+  ASSERT_TRUE(gdata_entry);
+  EXPECT_EQ(static_cast<int>(kNewContent.size()), gdata_entry->file_size());
 
   // Try to close the same file twice.
   file_system_->CloseFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // It must fail.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, error);
 }
@@ skipping 49 matching lines @@
       entry->resource_id(),
       entry->file_specific_info().md5(),
       google_apis::test_util::CreateCopyResultCallback(&success, &cache_entry));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_TRUE(success);
   EXPECT_FALSE(cache_entry.is_mounted());
 }
 
 }   // namespace drive