Revert 121620 - 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();
-  operation->set_write_callback(base::Bind(&Result::DidWrite,
-                                           base::Unretained(result)));
+  FileSystemOperation* operation = test_helper_.NewOperation(
+      new MockDispatcher(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