Cleanup FileSystemOperation for preparing for adding FSO-factory method

webkit/tools/test_shell/simple_file_writer.cc

 // Copyright (c) 2011 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_writer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 62 matching lines @@
     if (!io_thread_->BelongsToCurrentThread()) {
       io_thread_->PostTask(
           FROM_HERE,
           base::Bind(&IOThreadProxy::Cancel, this));
       return;
     }
     if (!operation_) {
       DidFail(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
       return;
     }
-    operation_->Cancel(GetNewOperation());
+    operation_->Cancel(CallbackDispatcher::Create(this));
   }
 
  private:
   // Inner class to receive callbacks from FileSystemOperation.
   class CallbackDispatcher : public FileSystemCallbackDispatcher {
    public:
-    explicit CallbackDispatcher(IOThreadProxy* proxy) : proxy_(proxy) {
+    // An instance of this class must be created by Create()
+    // (so that we do not leak ownerships).
+    static scoped_ptr<FileSystemCallbackDispatcher> Create(
+        IOThreadProxy* proxy) {
+      return scoped_ptr<FileSystemCallbackDispatcher>(
+          new CallbackDispatcher(proxy));
     }
 
     ~CallbackDispatcher() {
       proxy_->ClearOperation();
     }
 
     virtual void DidSucceed() {
       proxy_->DidSucceed();
     }
 
@@ skipping 16 matching lines @@
         bool has_more) {
       NOTREACHED();
     }
 
     virtual void DidOpenFileSystem(
         const std::string& name,
         const GURL& root) {
       NOTREACHED();
     }
 
+   private:
+    explicit CallbackDispatcher(IOThreadProxy* proxy) : proxy_(proxy) {}
     scoped_refptr<IOThreadProxy> proxy_;
   };
 
   FileSystemOperation* GetNewOperation() {
     // The FileSystemOperation takes ownership of the CallbackDispatcher.
-    return new FileSystemOperation(new CallbackDispatcher(this),
+    return new FileSystemOperation(CallbackDispatcher::Create(this),
                                    io_thread_, file_system_context_.get());
   }
 
   void DidSucceed() {
     if (!main_thread_->BelongsToCurrentThread()) {
       main_thread_->PostTask(
           FROM_HERE,
           base::Bind(&IOThreadProxy::DidSucceed, this));
       return;
     }
@@ skipping 57 matching lines @@
 }
 
 void SimpleFileWriter::DoWrite(
     const GURL& path, const GURL& blob_url, int64 offset) {
   io_thread_proxy_->Write(path, blob_url, offset);
 }
 
 void SimpleFileWriter::DoCancel() {
   io_thread_proxy_->Cancel();
 }