Refactor FileSystemOperation to take callback for each method.

webkit/fileapi/file_writer_delegate_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.
 //
 // NOTE: These tests are run as part of "unit_tests" (in chrome/test/unit)
 // rather than as part of test_shell_tests because they rely on being able
 // to instantiate a MessageLoop of type TYPE_IO.  test_shell_tests uses
 // TYPE_UI, which URLRequest doesn't allow.
 //
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/platform_test.h"
-#include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 namespace fileapi {
 
 namespace {
 
 class Result {
  public:
   Result()
       : status_(base::PLATFORM_FILE_OK),
         bytes_written_(0),
         complete_(false) {}
 
-  void set_failure_status(base::PlatformFileError status) {
-    EXPECT_FALSE(complete_);
-    EXPECT_EQ(status_, base::PLATFORM_FILE_OK);
-    EXPECT_NE(status, base::PLATFORM_FILE_OK);
-    complete_ = true;
-    status_ = status;
-  }
   base::PlatformFileError status() const { return status_; }
   void add_bytes_written(int64 bytes, bool complete) {
     bytes_written_ += bytes;
     EXPECT_FALSE(complete_);
     complete_ = complete;
   }
   int64 bytes_written() const { return bytes_written_; }
   bool complete() const { return complete_; }
 
+  void DidWrite(base::PlatformFileError status, int64 bytes, bool complete) {
+    if (status == base::PLATFORM_FILE_OK) {
+      add_bytes_written(bytes, complete);
+      if (complete)
+        MessageLoop::current()->Quit();
+    } else {
+      EXPECT_FALSE(complete_);
+      EXPECT_EQ(status_, base::PLATFORM_FILE_OK);
+      complete_ = true;
+      status_ = status;
+      MessageLoop::current()->Quit();
+    }
+  }
+
  private:
   // For post-operation status.
   base::PlatformFileError status_;
   int64 bytes_written_;
   bool complete_;
 };
 
 const char kData[] = "The quick brown fox jumps over the lazy dog.\n";
 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1;
 
@@ skipping 96 matching lines @@
   virtual int GetResponseCode() const OVERRIDE {
     return 200;
   }
 
  private:
   std::string content_;
   int remaining_bytes_;
   int cursor_;
 };
 
-class MockDispatcher : public FileSystemCallbackDispatcher {
- public:
-  explicit MockDispatcher(Result* result) : result_(result) {}
-
-  virtual void DidFail(base::PlatformFileError status) {
-    result_->set_failure_status(status);
-    MessageLoop::current()->Quit();
-  }
-
-  virtual void DidSucceed() {
-    ADD_FAILURE();
-  }
-
-  virtual void DidReadMetadata(
-      const base::PlatformFileInfo& info,
-      const FilePath& platform_path) {
-    ADD_FAILURE();
-  }
-
-  virtual void DidReadDirectory(
-      const std::vector<base::FileUtilProxy::Entry>& entries,
-      bool /* has_more */) {
-    ADD_FAILURE();
-  }
-
-  virtual void DidOpenFileSystem(const std::string&, const GURL&) {
-    ADD_FAILURE();
-  }
-
-  virtual void DidWrite(int64 bytes, bool complete) {
-    result_->add_bytes_written(bytes, complete);
-    if (complete)
-      MessageLoop::current()->Quit();
-  }
-
- private:
-  Result* result_;
-};
-
 }  // namespace (anonymous)
 
 // static
 net::URLRequestJob* FileWriterDelegateTest::Factory(
     net::URLRequest* request,
     const std::string& scheme) {
   return new FileWriterDelegateTestJob(
       request, FileWriterDelegateTest::content_);
 }
 
 void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(dir_.CreateUniqueTempDir());
   FilePath base_dir = dir_.path().AppendASCII("filesystem");
   SetUpTestHelper(base_dir);
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(
       test_helper_.GetOriginRootPath(), &file_path_));
   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory);
 }
 
 void FileWriterDelegateTest::TearDown() {
   net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL);
   base::ClosePlatformFile(file_);
   test_helper_.TearDown();
 }
 
 FileSystemOperation* FileWriterDelegateTest::CreateNewOperation(
     Result* result, int64 quota) {
-  FileSystemOperation* operation = test_helper_.NewOperation(
-      new MockDispatcher(result));
+  FileSystemOperation* operation = test_helper_.NewOperation();
+  operation->set_write_callback(base::Bind(&Result::DidWrite,
+                                           base::Unretained(result)));
   FileSystemOperationContext* context =
       operation->file_system_operation_context();
   context->set_allowed_bytes_growth(quota);
   return operation;
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
@@ skipping 199 matching lines @@
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status());
   EXPECT_TRUE(result_->complete());
 }
 
 class FileWriterDelegateUnlimitedTest : public FileWriterDelegateTest {
  protected:
   virtual void SetUpTestHelper(const FilePath& path) OVERRIDE;
 };
 
 }  // namespace fileapi