Add update observer to file_system_operation_impl_unittest for

content/browser/fileapi/file_system_operation_impl_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 "storage/browser/fileapi/file_system_operation_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/fileapi/mock_file_change_observer.h"
+#include "content/browser/fileapi/mock_file_update_observer.h"
 #include "content/browser/quota/mock_quota_manager.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/sandbox_file_system_test_helper.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_file_util.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
 #include "storage/browser/fileapi/file_system_operation_runner.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend.h"
 #include "storage/browser/quota/quota_manager.h"
@@ skipping 18 matching lines @@
 class FileSystemOperationImplTest
     : public testing::Test {
  public:
   FileSystemOperationImplTest() : weak_factory_(this) {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
     change_observers_ =
         storage::MockFileChangeObserver::CreateList(&change_observer_);
+    update_observers_ =
+        storage::MockFileUpdateObserver::CreateList(&update_observer_);
 
     base::FilePath base_dir = base_.path().AppendASCII("filesystem");
     quota_manager_ =
         new MockQuotaManager(false /* is_incognito */,
                                     base_dir,
                                     base::MessageLoopProxy::current().get(),
                                     base::MessageLoopProxy::current().get(),
                                     NULL /* special storage policy */);
     quota_manager_proxy_ = new MockQuotaManagerProxy(
         quota_manager(), base::MessageLoopProxy::current().get());
     sandbox_file_system_.SetUp(base_dir, quota_manager_proxy_.get());
     sandbox_file_system_.AddFileChangeObserver(&change_observer_);
+    sandbox_file_system_.AddFileUpdateObserver(&update_observer_);
+    update_observer_.EndCount();

[tzik, 2014/09/19 03:43:59]

EndCount() looks a bit weird.
How about renaming it with {Enable,Disable}Verification()?

[iseki, 2014/09/19 04:55:29]

Done.

   }
 
   virtual void TearDown() OVERRIDE {
     // Let the client go away before dropping a ref of the quota manager proxy.
     quota_manager_proxy()->SimulateQuotaManagerDestroyed();
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
     sandbox_file_system_.TearDown();
   }
 
@@ skipping 209 matching lines @@
                               sandbox_file_system_.storage_type(),
                               quota + quota_delta);
   }
 
   base::File::Error Move(
       const FileSystemURL& src,
       const FileSystemURL& dest,
       storage::FileSystemOperation::CopyOrMoveOption option) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->Move(
         src,
         dest,
         option,
         RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error Copy(
       const FileSystemURL& src,
       const FileSystemURL& dest,
       storage::FileSystemOperation::CopyOrMoveOption option) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->Copy(
         src,
         dest,
         option,
         FileSystemOperationRunner::CopyProgressCallback(),
         RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error CopyInForeignFile(const base::FilePath& src,
                                       const FileSystemURL& dest) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->CopyInForeignFile(
         src, dest, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error Truncate(const FileSystemURL& url, int size) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->Truncate(
         url, size, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error CreateFile(const FileSystemURL& url, bool exclusive) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->CreateFile(
         url, exclusive, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error Remove(const FileSystemURL& url, bool recursive) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->Remove(
         url, recursive, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error CreateDirectory(const FileSystemURL& url,
                                     bool exclusive,
                                     bool recursive) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->CreateDirectory(
         url,
         exclusive,
         recursive,
         RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error GetMetadata(const FileSystemURL& url) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->GetMetadata(
         url, RecordMetadataCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error ReadDirectory(const FileSystemURL& url) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->ReadDirectory(
         url, RecordReadDirectoryCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error CreateSnapshotFile(const FileSystemURL& url) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->CreateSnapshotFile(
         url, RecordSnapshotFileCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error FileExists(const FileSystemURL& url) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->FileExists(
         url, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error DirectoryExists(const FileSystemURL& url) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->DirectoryExists(
         url, RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
   base::File::Error TouchFile(const FileSystemURL& url,
                               const base::Time& last_access_time,
                               const base::Time& last_modified_time) {
     base::File::Error status;
     base::RunLoop run_loop;
+    update_observer_.StartCount();
     operation_runner()->TouchFile(
         url,
         last_access_time,
         last_modified_time,
         RecordStatusCallback(run_loop.QuitClosure(), &status));
     run_loop.Run();
+    update_observer_.EndCount();
     return status;
   }
 
  private:
   base::MessageLoopForIO message_loop_;
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
 
   // Common temp base for nondestructive uses.
   base::ScopedTempDir base_;
 
   SandboxFileSystemTestHelper sandbox_file_system_;
 
   // For post-operation status.
   base::File::Info info_;
   base::FilePath path_;
   std::vector<storage::DirectoryEntry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
   storage::MockFileChangeObserver change_observer_;
   storage::ChangeObserverList change_observers_;
+  storage::MockFileUpdateObserver update_observer_;
+  storage::UpdateObserverList update_observers_;
 
   base::WeakPtrFactory<FileSystemOperationImplTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationImplTest);
 };
 
 TEST_F(FileSystemOperationImplTest, TestMoveFailureSrcDoesntExist) {
   change_observer()->ResetCount();
   EXPECT_EQ(
       base::File::FILE_ERROR_NOT_FOUND,
@@ skipping 798 matching lines @@
   FileSystemURL src_file(CreateFile("src"));
   FileSystemURL dest_file(CreateFile("dest"));
 
   EXPECT_EQ(base::File::FILE_OK, Truncate(dest_file, 6));
   EXPECT_EQ(base::File::FILE_OK,
             Copy(src_file, dest_file, FileSystemOperation::OPTION_NONE));
   EXPECT_EQ(0, GetFileSize("dest"));
 }
 
 }  // namespace content