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_->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 586 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.
+  entry = GetResourceEntryByPathSync(kFileInRoot);

[kinaba, 2013/06/11 07:08:37]

GetResourceEntryByPathSync ends up with local resource metadata look up.
To test that it is indeed synced, I think we should query fake_drive_service
here.

[hashimoto, 2013/06/11 07:37:57]

Good catch, I should have checked the change stamp or used
FakeDriveService::GetResourceEntry as you say.
Switched to check with fake_drive_service_.

+  ASSERT_TRUE(entry);
+  EXPECT_EQ(static_cast<int>(kNewContent.size()), entry->file_info().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