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"
@@ skipping 12 matching lines @@
 #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_);
   }
@@ skipping 120 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,
+                           new BrowserFileSystemCallbackDispatcher(
+                               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(new BrowserFileSystemCallbackDispatcher(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 43 matching lines @@
       new BrowserFileSystemCallbackDispatcher(this, request_id);
   FileSystemOperation* operation = new FileSystemOperation(
       dispatcher,
       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);
 }