Cleanup FileSystemOperation for preparing for adding FSO-factory method

webkit/tools/test_shell/simple_file_system.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.
 
 #include "webkit/tools/test_shell/simple_file_system.h"
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
@@ skipping 31 matching lines @@
 
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperation;
 
 namespace {
 
 class SimpleFileSystemCallbackDispatcher
     : public FileSystemCallbackDispatcher {
  public:
-  SimpleFileSystemCallbackDispatcher(
+  // An instance of this class must be created by Create()
+  // (so that we do not leak ownerships).
+  static scoped_ptr<FileSystemCallbackDispatcher> Create(
       const WeakPtr<SimpleFileSystem>& file_system,
-      WebFileSystemCallbacks* callbacks)
-      : file_system_(file_system),
-        callbacks_(callbacks) {
+      WebFileSystemCallbacks* callbacks) {
+    return scoped_ptr<FileSystemCallbackDispatcher>(
+        new SimpleFileSystemCallbackDispatcher(file_system, callbacks));
   }
 
   ~SimpleFileSystemCallbackDispatcher() {
   }
 
   virtual void DidSucceed() {
     DCHECK(file_system_);
     callbacks_->didSucceed();
   }
 
@@ skipping 40 matching lines @@
     DCHECK(file_system_);
     callbacks_->didFail(
         webkit_glue::PlatformFileErrorToWebFileError(error_code));
   }
 
   virtual void DidWrite(int64, bool) {
     NOTREACHED();
   }
 
  private:
+  SimpleFileSystemCallbackDispatcher(
+      const WeakPtr<SimpleFileSystem>& file_system,
+      WebFileSystemCallbacks* callbacks)
+      : file_system_(file_system),
+        callbacks_(callbacks) {
+  }
+
   WeakPtr<SimpleFileSystem> file_system_;
   WebFileSystemCallbacks* callbacks_;
 };
 
 }  // namespace
 
 SimpleFileSystem::SimpleFileSystem() {
   if (file_system_dir_.CreateUniqueTempDir()) {
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
@@ skipping 28 matching lines @@
     type = fileapi::kFileSystemTypePersistent;
   else if (web_filesystem_type == WebFileSystem::TypeExternal)
     type = fileapi::kFileSystemTypeExternal;
   else {
     // Unknown type filesystem is requested.
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
 
   GURL origin_url(frame->document().securityOrigin().toString());
-  GetNewOperation(callbacks)->OpenFileSystem(origin_url, type, create);
+  file_system_context_->OpenFileSystem(
+      origin_url, type, create,
+      SimpleFileSystemCallbackDispatcher::Create(AsWeakPtr(), callbacks));
 }
 
 void SimpleFileSystem::move(
     const WebURL& src_path,
     const WebURL& dest_path, WebFileSystemCallbacks* callbacks) {
   GetNewOperation(callbacks)->Move(GURL(src_path), GURL(dest_path));
 }
 
 void SimpleFileSystem::copy(
     const WebURL& src_path, const WebURL& dest_path,
@@ skipping 41 matching lines @@
   GetNewOperation(callbacks)->ReadDirectory(path);
 }
 
 WebFileWriter* SimpleFileSystem::createFileWriter(
     const WebURL& path, WebFileWriterClient* client) {
   return new SimpleFileWriter(path, client, file_system_context_.get());
 }
 
 FileSystemOperation* SimpleFileSystem::GetNewOperation(
     WebFileSystemCallbacks* callbacks) {
-  SimpleFileSystemCallbackDispatcher* dispatcher =
-      new SimpleFileSystemCallbackDispatcher(AsWeakPtr(), callbacks);
   FileSystemOperation* operation = new FileSystemOperation(
-      dispatcher, base::MessageLoopProxy::current(),
+      SimpleFileSystemCallbackDispatcher::Create(AsWeakPtr(), callbacks),
+      base::MessageLoopProxy::current(),
       file_system_context_.get());
   return operation;
 }