Cleanup FileSystemOperation for preparing for adding FSO-factory method

content/browser/file_system/file_system_dispatcher_host.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 "content/browser/file_system/file_system_dispatcher_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "content/common/file_system_messages.h"
 #include "content/public/browser/user_metrics.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_platform_file.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.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.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::UserMetricsAction;
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
-using fileapi::FileSystemOperationContext;
 
 class BrowserFileSystemCallbackDispatcher
     : public FileSystemCallbackDispatcher {
  public:
-  BrowserFileSystemCallbackDispatcher(
-      FileSystemDispatcherHost* dispatcher_host, int request_id)
-      : dispatcher_host_(dispatcher_host),
-        request_id_(request_id) {
-    DCHECK(dispatcher_host_);
+  // An instance of this class must be created by Create()
+  // (so that we do not leak ownerships).
+  static scoped_ptr<FileSystemCallbackDispatcher> Create(
+      FileSystemDispatcherHost* dispatcher_host, int request_id) {
+    return scoped_ptr<FileSystemCallbackDispatcher>(
+        new BrowserFileSystemCallbackDispatcher(dispatcher_host, request_id));
   }
 
   virtual ~BrowserFileSystemCallbackDispatcher() {
     dispatcher_host_->UnregisterOperation(request_id_);
   }
 
   virtual void DidSucceed() {
     dispatcher_host_->Send(new FileSystemMsg_DidSucceed(request_id_));
   }
 
@@ skipping 32 matching lines @@
     IPC::PlatformFileForTransit file_for_transit =
         file != base::kInvalidPlatformFileValue ?
             IPC::GetFileHandleForProcess(file, peer_handle, true) :
             IPC::InvalidPlatformFileForTransit();
 
     dispatcher_host_->Send(new FileSystemMsg_DidOpenFile(
         request_id_, file_for_transit));
   }
 
  private:
+  BrowserFileSystemCallbackDispatcher(
+      FileSystemDispatcherHost* dispatcher_host, int request_id)
+      : dispatcher_host_(dispatcher_host),
+        request_id_(request_id) {
+    DCHECK(dispatcher_host_);
+  }
+
   scoped_refptr<FileSystemDispatcherHost> dispatcher_host_;
   int request_id_;
 };
 
 FileSystemDispatcherHost::FileSystemDispatcherHost(
     net::URLRequestContextGetter* request_context_getter,
     fileapi::FileSystemContext* file_system_context)
     : context_(file_system_context),
       request_context_getter_(request_context_getter),
       request_context_(NULL) {
@@ skipping 59 matching lines @@
 }
 
 void FileSystemDispatcherHost::OnOpen(
     int request_id, const GURL& origin_url, fileapi::FileSystemType type,
     int64 requested_size, bool create) {
   if (type == fileapi::kFileSystemTypeTemporary) {
     content::RecordAction(UserMetricsAction("OpenFileSystemTemporary"));
   } else if (type == fileapi::kFileSystemTypePersistent) {
     content::RecordAction(UserMetricsAction("OpenFileSystemPersistent"));
   }
-  GetNewOperation(request_id)->OpenFileSystem(origin_url, type, create);
+  context_->OpenFileSystem(origin_url, type, create,
+                           BrowserFileSystemCallbackDispatcher::Create(
+                               this, request_id));
 }
 
 void FileSystemDispatcherHost::OnMove(
     int request_id, const GURL& src_path, const GURL& dest_path) {
   GetNewOperation(request_id)->Move(src_path, dest_path);
 }
 
 void FileSystemDispatcherHost::OnCopy(
     int request_id, const GURL& src_path, const GURL& dest_path) {
   GetNewOperation(request_id)->Copy(src_path, dest_path);
@@ skipping 62 matching lines @@
 }
 
 void FileSystemDispatcherHost::OnCancel(
     int request_id,
     int request_id_to_cancel) {
   FileSystemOperation* write = operations_.Lookup(
       request_id_to_cancel);
   if (write) {
     // The cancel will eventually send both the write failure and the cancel
     // success.
-    write->Cancel(GetNewOperation(request_id));
+    write->Cancel(
+        BrowserFileSystemCallbackDispatcher::Create(this, request_id));
   } else {
     // The write already finished; report that we failed to stop it.
     Send(new FileSystemMsg_DidFail(
         request_id, base::PLATFORM_FILE_ERROR_INVALID_OPERATION));
   }
 }
 
 void FileSystemDispatcherHost::OnOpenFile(
     int request_id, const GURL& path, int file_flags) {
   GetNewOperation(request_id)->OpenFile(path, file_flags, peer_handle());
@@ skipping 23 matching lines @@
   quota_util->proxy()->EndUpdateOrigin(origin_url, type);
 }
 
 void FileSystemDispatcherHost::OnSyncGetPlatformPath(
     const GURL& path, FilePath* platform_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(platform_path);
   *platform_path = FilePath();
 
   FileSystemOperation* operation = new FileSystemOperation(
-      NULL,
+      scoped_ptr<FileSystemCallbackDispatcher>(NULL),
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       context_);
 
   operation->SyncGetPlatformPath(path, platform_path);
 }
 
 FileSystemOperation* FileSystemDispatcherHost::GetNewOperation(
     int request_id) {
-  BrowserFileSystemCallbackDispatcher* dispatcher =
-      new BrowserFileSystemCallbackDispatcher(this, request_id);
   FileSystemOperation* operation = new FileSystemOperation(
-      dispatcher,
+      BrowserFileSystemCallbackDispatcher::Create(this, request_id),
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       context_);
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 void FileSystemDispatcherHost::UnregisterOperation(int request_id) {
-  DCHECK(operations_.Lookup(request_id));
-  operations_.Remove(request_id);
+  // For Cancel and OpenFileSystem we do not create an operation.
+  if (operations_.Lookup(request_id))
+    operations_.Remove(request_id);
 }