drive: Remove FileCacheObserver::OnCacheCommitted

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

 // Copyright 2013 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/copy_operation.h"
 
 #include "base/file_util.h"
 #include "chrome/browser/chromeos/drive/file_cache_observer.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_test_base.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/google_apis/fake_drive_service.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace file_system {
 
-namespace {
-class CacheCommitObserver : public internal::FileCacheObserver {
- public:
-  virtual void OnCacheCommitted(const std::string& resource_id) OVERRIDE {
-   last_committed_resource_id_ = resource_id;
-  }
-  const std::string last_committed_resource_id() const {
-    return last_committed_resource_id_;
-  }
-
- private:
-  std::string last_committed_resource_id_;
-};
-
-}  // namespace
-
 class CopyOperationTest : public OperationTestBase {
  protected:
   virtual void SetUp() OVERRIDE {
    OperationTestBase::SetUp();
    operation_.reset(new CopyOperation(blocking_task_runner(),
                                       observer(),
                                       scheduler(),
                                       metadata(),
                                       cache(),
                                       fake_service()));
   }
 
   scoped_ptr<CopyOperation> operation_;
 };
 
 TEST_F(CopyOperationTest, TransferFileFromLocalToRemote_RegularFile) {
   const base::FilePath local_src_path = temp_dir().AppendASCII("local.txt");
   const base::FilePath remote_dest_path(
       FILE_PATH_LITERAL("drive/root/remote.txt"));
 
   // Prepare a local file.
   ASSERT_TRUE(
       google_apis::test_util::WriteStringToFile(local_src_path, "hello"));
   // Confirm that the remote file does not exist.
   ResourceEntry entry;
   ASSERT_EQ(FILE_ERROR_NOT_FOUND,
             GetLocalResourceEntry(remote_dest_path, &entry));
 
-  CacheCommitObserver cache_observer;
-  cache()->AddObserver(&cache_observer);
-
   // Transfer the local file to Drive.
   FileError error = FILE_ERROR_FAILED;
   operation_->TransferFileFromLocalToRemote(
       local_src_path,
       remote_dest_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
-  // What TransferFileFromLocalToRemote does is to store the local file in
-  // the Drive file cache, and mark it as dirty+committed. Here we test that
-  // the "cache committed" event is indeed fired as a result of this test case.
-  //
-  // In the production environment, SyncClient listens this event and uploads
-  // the file to the remote server in background. This part should be tested in
-  // sync_client_unittest.cc
+  // TransferFileFromLocalToRemote stores a copy of the local file in the cache,
+  // marks it dirty and requests the observer to upload the file.
   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(remote_dest_path, &entry));
-  EXPECT_FALSE(cache_observer.last_committed_resource_id().empty());
-  EXPECT_EQ(entry.resource_id(), cache_observer.last_committed_resource_id());
+  EXPECT_EQ(1U, observer()->upload_needed_resource_ids().count(
+      entry.resource_id()));
+  FileCacheEntry cache_entry;
+  bool found = false;
+  cache()->GetCacheEntryOnUIThread(
+      entry.resource_id(), std::string(),
+      google_apis::test_util::CreateCopyResultCallback(&found, &cache_entry));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_TRUE(found);
+  EXPECT_TRUE(cache_entry.is_present());
+  EXPECT_TRUE(cache_entry.is_dirty());
 
   EXPECT_EQ(1U, observer()->get_changed_paths().size());
   EXPECT_TRUE(observer()->get_changed_paths().count(
       remote_dest_path.DirName()));
 }
 
 TEST_F(CopyOperationTest, TransferFileFromLocalToRemote_HostedDocument) {
   const base::FilePath local_src_path = temp_dir().AppendASCII("local.gdoc");
   const base::FilePath remote_dest_path(FILE_PATH_LITERAL(
       "drive/root/Directory 1/Document 1 excludeDir-test.gdoc"));
@@ skipping 150 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(FILE_ERROR_NOT_A_DIRECTORY, error);
 
   EXPECT_EQ(FILE_ERROR_OK, GetLocalResourceEntry(src_path, &entry));
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, GetLocalResourceEntry(dest_path, &entry));
   EXPECT_TRUE(observer()->get_changed_paths().empty());
 }
 
 }  // namespace file_system
 }  // namespace drive