2 files changed, 47 insertions, 184 deletions

diff --git a/chrome/common/file_system/webfilewriter_impl.cc b/chrome/common/file_system/webfilewriter_impl.cc
index 6314c91..2f3677b 100644
--- a/chrome/common/file_system/webfilewriter_impl.cc
+++ b/chrome/common/file_system/webfilewriter_impl.cc
@@ -5,19 +5,23 @@
 #include "chrome/common/file_system/webfilewriter_impl.h"
 
 #include "chrome/common/child_thread.h"
-#include "chrome/common/file_system/webfilesystem_impl.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFileError.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFileWriterClient.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURL.h"
-#include "webkit/glue/webkit_glue.h"
+#include "chrome/common/file_system/file_system_dispatcher.h"
 
-class WebFileWriterImpl::FileSystemCallbackDispatcherImpl :
-    public fileapi::FileSystemCallbackDispatcher {
+namespace {
+
+inline FileSystemDispatcher* GetFileSystemDispatcher() {
+  return ChildThread::current()->file_system_dispatcher();
+}
+
+}
+
+class WebFileWriterImpl::CallbackDispatcher
+    : public fileapi::FileSystemCallbackDispatcher {
  public:
-  explicit FileSystemCallbackDispatcherImpl(
-      const base::WeakPtr<WebFileWriterImpl>& impl) : m_impl(impl) {
+  explicit CallbackDispatcher(
+      const base::WeakPtr<WebFileWriterImpl>& writer) : writer_(writer) {
   }
-  virtual ~FileSystemCallbackDispatcherImpl() {
+  virtual ~CallbackDispatcher() {
   }
 
   virtual void DidReadMetadata(const base::PlatformFileInfo&) {
@@ -33,162 +37,45 @@ class WebFileWriterImpl::FileSystemCallbackDispatcherImpl :
     NOTREACHED();
   }
   virtual void DidSucceed() {
-    if (m_impl)
-      m_impl->DidSucceed();
+    if (writer_)
+      writer_->DidSucceed();
   }
   virtual void DidFail(base::PlatformFileError error_code) {
-    if (m_impl)
-      m_impl->DidFail(error_code);
+    if (writer_)
+      writer_->DidFail(error_code);
   }
   virtual void DidWrite(int64 bytes, bool complete) {
-    if (m_impl)
-      m_impl->DidWrite(bytes, complete);
+    if (writer_)
+      writer_->DidWrite(bytes, complete);
   }
 
  private:
-  base::WeakPtr<WebFileWriterImpl> m_impl;
+  base::WeakPtr<WebFileWriterImpl> writer_;
 };
 
 WebFileWriterImpl::WebFileWriterImpl(
      const WebKit::WebString& path, WebKit::WebFileWriterClient* client)
-  : path_(webkit_glue::WebStringToFilePath(path)),
-    client_(client),
-    request_id_(0),
-    operation_(kOperationNone),
-    cancel_state_(kCancelNotInProgress) {
+  : WebFileWriterBase(path, client),
+    request_id_(0) {
 }
 
 WebFileWriterImpl::~WebFileWriterImpl() {
 }
 
-void WebFileWriterImpl::truncate(
-      long long length) {
-  DCHECK(kOperationNone == operation_);
-  DCHECK(kCancelNotInProgress == cancel_state_);
-  operation_ = kOperationTruncate;
-  FileSystemDispatcher* dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  dispatcher->Truncate(
-      path_, length, &request_id_,
-      new FileSystemCallbackDispatcherImpl(AsWeakPtr()));
-}
-
-void WebFileWriterImpl::write(
-      long long position,
-      const WebKit::WebURL& blob_url) {
-  DCHECK(kOperationNone == operation_);
-  DCHECK(kCancelNotInProgress == cancel_state_);
-  operation_ = kOperationWrite;
-  FileSystemDispatcher* dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  dispatcher->Write(
-      path_, blob_url, position, &request_id_,
-      new FileSystemCallbackDispatcherImpl(AsWeakPtr()));
-}
-
-// When we cancel a write/truncate, we always get back the result of the write
-// before the result of the cancel, no matter what happens.
-// So we'll get back either
-//   success [of the write/truncate, in a DidWrite(XXX, true)/DidSucceed() call]
-//     followed by failure [of the cancel]; or
-//   failure [of the write, either from cancel or other reasons] followed by
-//     the result of the cancel.
-// In the write case, there could also be queued up non-terminal DidWrite calls
-// before any of that comes back, but there will always be a terminal write
-// response [success or failure] after them, followed by the cancel result, so
-// we can ignore non-terminal write responses, take the terminal write success
-// or the first failure as the last write response, then know that the next
-// thing to come back is the cancel response.  We only notify the
-// AsyncFileWriterClient when it's all over.
-void WebFileWriterImpl::cancel() {
-  DCHECK(kOperationWrite == operation_ || kOperationTruncate == operation_);
-  if (kCancelNotInProgress != cancel_state_)
-    return;
-  cancel_state_ = kCancelSent;
-  FileSystemDispatcher* dispatcher =
-      ChildThread::current()->file_system_dispatcher();
-  dispatcher->Cancel(
-      request_id_, new FileSystemCallbackDispatcherImpl(AsWeakPtr()));
-}
-
-void WebFileWriterImpl::DidSucceed() {
-  // Write never gets a DidSucceed call, so this is either a cancel or truncate
-  // response.
-  switch (cancel_state_) {
-    case kCancelNotInProgress:
-      // A truncate succeeded, with no complications.
-      DCHECK(kOperationTruncate == operation_);
-      operation_ = kOperationNone;
-      client_->didTruncate();
-      break;
-    case kCancelSent:
-      DCHECK(kOperationTruncate == operation_);
-      // This is the success call of the truncate, which we'll eat, even though
-      // it succeeded before the cancel got there.  We accepted the cancel call,
-      // so the truncate will eventually return an error.
-      cancel_state_ = kCancelReceivedWriteResponse;
-      break;
-    case kCancelReceivedWriteResponse:
-      // This is the success of the cancel operation.
-      FinishCancel();
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
-void WebFileWriterImpl::DidFail(base::PlatformFileError error_code) {
-  DCHECK(kOperationNone != operation_);
-  switch (cancel_state_) {
-    case kCancelNotInProgress:
-      // A write or truncate failed.
-      operation_ = kOperationNone;
-      client_->didFail(
-          webkit_glue::PlatformFileErrorToWebFileError(error_code));
-      break;
-    case kCancelSent:
-      // This is the failure of a write or truncate; the next message should be
-      // the result of the cancel.  We don't assume that it'll be a success, as
-      // the write/truncate could have failed for other reasons.
-      cancel_state_ = kCancelReceivedWriteResponse;
-      break;
-    case kCancelReceivedWriteResponse:
-      // The cancel reported failure, meaning that the write or truncate
-      // finished before the cancel got there.  But we suppressed the
-      // write/truncate's response, and will now report that it was cancelled.
-      FinishCancel();
-      break;
-    default:
-      NOTREACHED();
-  }
+void WebFileWriterImpl::DoTruncate(const FilePath& path, int64 offset) {
+  // The FileSystemDispatcher takes ownership of the CallbackDispatcher.
+  GetFileSystemDispatcher()->Truncate(path, offset, &request_id_,
+                                      new CallbackDispatcher(AsWeakPtr()));
 }
 
-void WebFileWriterImpl::DidWrite(int64 bytes, bool complete) {
-  DCHECK(kOperationWrite == operation_);
-  switch (cancel_state_) {
-    case kCancelNotInProgress:
-      if (complete)
-        operation_ = kOperationNone;
-      client_->didWrite(bytes, complete);
-      break;
-    case kCancelSent:
-      // This is the success call of the write, which we'll eat, even though
-      // it succeeded before the cancel got there.  We accepted the cancel call,
-      // so the write will eventually return an error.
-      if (complete)
-        cancel_state_ = kCancelReceivedWriteResponse;
-      break;
-    case kCancelReceivedWriteResponse:
-    default:
-      NOTREACHED();
-  }
+void WebFileWriterImpl::DoWrite(
+    const FilePath& path, const GURL& blob_url, int64 offset) {
+  GetFileSystemDispatcher()->Write(path, blob_url, offset, &request_id_,
+                                   new CallbackDispatcher(AsWeakPtr()));
 }
 
-void WebFileWriterImpl::FinishCancel() {
-  DCHECK(kCancelReceivedWriteResponse == cancel_state_);
-  DCHECK(kOperationNone != operation_);
-  cancel_state_ = kCancelNotInProgress;
-  operation_ = kOperationNone;
-  client_->didFail(WebKit::WebFileErrorAbort);
+void WebFileWriterImpl::DoCancel() {
+  GetFileSystemDispatcher()->Cancel(request_id_,
+                                    new CallbackDispatcher(AsWeakPtr()));
 }
 
diff --git a/chrome/common/file_system/webfilewriter_impl.h b/chrome/common/file_system/webfilewriter_impl.h
index 6f1c0a7..9c9edb5 100644
--- a/chrome/common/file_system/webfilewriter_impl.h
+++ b/chrome/common/file_system/webfilewriter_impl.h
@@ -5,54 +5,30 @@
 #ifndef CHROME_COMMON_FILE_SYSTEM_WEBFILEWRITER_IMPL_H_
 #define CHROME_COMMON_FILE_SYSTEM_WEBFILEWRITER_IMPL_H_
 
-#include "base/basictypes.h"
+#include "base/ref_counted.h"
 #include "base/weak_ptr.h"
-#include "chrome/common/file_system/file_system_dispatcher.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFileWriter.h"
+#include "webkit/fileapi/webfilewriter_base.h"
 
-namespace WebKit {
-class WebFileWriterClient;
-class WebString;
-class WebURL;
-}
+class FileSystemDispatcher;
 
-class WebFileWriterImpl
-  : public WebKit::WebFileWriter,
-    public base::SupportsWeakPtr<WebFileWriterImpl> {
+// An implementation of WebFileWriter for use in chrome renderers and workers.
+class WebFileWriterImpl : public fileapi::WebFileWriterBase,
+                          public base::SupportsWeakPtr<WebFileWriterImpl> {
  public:
   WebFileWriterImpl(
       const WebKit::WebString& path, WebKit::WebFileWriterClient* client);
   virtual ~WebFileWriterImpl();
 
-  // WebFileWriter implementation
-  virtual void truncate(long long length);
-  virtual void write(long long position, const WebKit::WebURL& blobURL);
-  virtual void cancel();
+ protected:
+  // WebFileWriterBase overrides
+  virtual void DoTruncate(const FilePath& path, int64 offset);
+  virtual void DoWrite(const FilePath& path, const GURL& blob_url,
+                       int64 offset);
+  virtual void DoCancel();
 
  private:
-  class FileSystemCallbackDispatcherImpl;
-  enum OperationType {
-    kOperationNone,
-    kOperationWrite,
-    kOperationTruncate
-  };
-
-  enum CancelState {
-    kCancelNotInProgress,
-    kCancelSent,
-    kCancelReceivedWriteResponse,
-  };
-
-  void DidSucceed();
-  void DidFail(base::PlatformFileError error_code);
-  void DidWrite(int64 bytes, bool complete);
-  void FinishCancel();
-
-  FilePath path_;
-  WebKit::WebFileWriterClient* client_;
+  class CallbackDispatcher;
   int request_id_;
-  OperationType operation_;
-  CancelState cancel_state_;
 };
 
 #endif  // CHROME_COMMON_FILE_SYSTEM_WEBFILEWRITER_IMPL_H_