Add CreateFileSystemOperation() method to FileSystemContext

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/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"
+#include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::UserMetricsAction;
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
+using fileapi::FileSystemOperationInterface;
 
 class BrowserFileSystemCallbackDispatcher
     : public FileSystemCallbackDispatcher {
  public:
   BrowserFileSystemCallbackDispatcher(
       FileSystemDispatcherHost* dispatcher_host, int request_id)
       : dispatcher_host_(dispatcher_host),
         request_id_(request_id) {
     DCHECK(dispatcher_host_);
   }
@@ skipping 126 matching lines @@
     content::RecordAction(UserMetricsAction("OpenFileSystemTemporary"));
   } else if (type == fileapi::kFileSystemTypePersistent) {
     content::RecordAction(UserMetricsAction("OpenFileSystemPersistent"));
   }
   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) {

[ericu, 2012/01/10 00:37:04]

Where are we going to handle issues involving moves/copies that involve two
different types of FileSystemOperations?

[kinuko, 2012/01/13 08:28:35]

As we talked before I'm putting it off for now.  I'm vaguely assuming that we
will need to do something like 1) change the per-operation CallbackDispatcher
architecture (e.g. replacing it with per-method regular callbacks) and 2)
implement cross-FSO operations above the individual FSO layer using lower FSO
routines like readDirectory, createOrOpenFile, createDirectory and etc.

(Filed a bug: http://codereview.chromium.org/8999017/)

-  GetNewOperation(request_id)->Move(src_path, dest_path);
+  GetNewOperation(src_path, 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);
+  GetNewOperation(src_path, request_id)->Copy(src_path, dest_path);
 }
 
 void FileSystemDispatcherHost::OnRemove(
     int request_id, const GURL& path, bool recursive) {
-  GetNewOperation(request_id)->Remove(path, recursive);
+  GetNewOperation(path, request_id)->Remove(path, recursive);
 }
 
 void FileSystemDispatcherHost::OnReadMetadata(
     int request_id, const GURL& path) {
-  GetNewOperation(request_id)->GetMetadata(path);
+  GetNewOperation(path, request_id)->GetMetadata(path);
 }
 
 void FileSystemDispatcherHost::OnCreate(
     int request_id, const GURL& path, bool exclusive,
     bool is_directory, bool recursive) {
   if (is_directory)
-    GetNewOperation(request_id)->CreateDirectory(path, exclusive, recursive);
+    GetNewOperation(path, request_id)->CreateDirectory(
+        path, exclusive, recursive);
   else
-    GetNewOperation(request_id)->CreateFile(path, exclusive);
+    GetNewOperation(path, request_id)->CreateFile(path, exclusive);
 }
 
 void FileSystemDispatcherHost::OnExists(
     int request_id, const GURL& path, bool is_directory) {
   if (is_directory)
-    GetNewOperation(request_id)->DirectoryExists(path);
+    GetNewOperation(path, request_id)->DirectoryExists(path);
   else
-    GetNewOperation(request_id)->FileExists(path);
+    GetNewOperation(path, request_id)->FileExists(path);
 }
 
 void FileSystemDispatcherHost::OnReadDirectory(
     int request_id, const GURL& path) {
-  GetNewOperation(request_id)->ReadDirectory(path);
+  GetNewOperation(path, request_id)->ReadDirectory(path);
 }
 
 void FileSystemDispatcherHost::OnWrite(
     int request_id,
     const GURL& path,
     const GURL& blob_url,
     int64 offset) {
   if (!request_context_) {
     // We can't write w/o a request context, trying to do so will crash.
     NOTREACHED();
     return;
   }
-  GetNewOperation(request_id)->Write(
+  GetNewOperation(path, request_id)->Write(
       request_context_, path, blob_url, offset);
 }
 
 void FileSystemDispatcherHost::OnTruncate(
     int request_id,
     const GURL& path,
     int64 length) {
-  GetNewOperation(request_id)->Truncate(path, length);
+  GetNewOperation(path, request_id)->Truncate(path, length);
 }
 
 void FileSystemDispatcherHost::OnTouchFile(
     int request_id,
     const GURL& path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
-  GetNewOperation(request_id)->TouchFile(
+  GetNewOperation(path, request_id)->TouchFile(
       path, last_access_time, last_modified_time);
 }
 
 void FileSystemDispatcherHost::OnCancel(
     int request_id,
     int request_id_to_cancel) {
-  FileSystemOperation* write = operations_.Lookup(
+  FileSystemOperationInterface* write = operations_.Lookup(
       request_id_to_cancel);
   if (write) {
     // The cancel will eventually send both the write failure and the cancel
     // success.
     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());
+  GetNewOperation(path, request_id)->OpenFile(path, file_flags, peer_handle());
 }
 
 void FileSystemDispatcherHost::OnWillUpdate(const GURL& path) {
   GURL origin_url;
   fileapi::FileSystemType type;
   if (!CrackFileSystemURL(path, &origin_url, &type, NULL))
     return;
   fileapi::FileSystemQuotaUtil* quota_util = context_->GetQuotaUtil(type);
   if (!quota_util)
     return;
@@ skipping 12 matching lines @@
       context_->quota_manager_proxy(), origin_url, type, delta);
   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,
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
-      context_);
+  GURL origin_url;
+  fileapi::FileSystemType file_system_type = fileapi::kFileSystemTypeUnknown;
+  FilePath file_path;
+  if (!fileapi::CrackFileSystemURL(
+          path, &origin_url, &file_system_type, &file_path)) {
+    return;
+  }
 
+  // We support sync operations only on TEMPORARY or PERSISTENT filesystems.
+  // (This is called only by pepper plugin as of writing.)
+  DCHECK(file_system_type == fileapi::kFileSystemTypeTemporary ||
+         file_system_type == fileapi::kFileSystemTypePersistent);
+
+  FileSystemOperation* operation = static_cast<FileSystemOperation*>(

[satorux1, 2011/12/27 20:55:34]

Is this a down cast? Can we avoid it? Otherwise, it'd be nice to add some
comment about why we need to do this here.

[kinuko, 2012/01/13 08:28:35]

Once we support asynchronous uploading for arbitrary filesystem files we should
be able to get rid of this dirty hack.  I've added comments about that and added
AsFileSystemOperation() virtual method for explicit downcasting.

+      context_->CreateFileSystemOperation(
+          path, NULL,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)));
   operation->SyncGetPlatformPath(path, platform_path);
 }
 
-FileSystemOperation* FileSystemDispatcherHost::GetNewOperation(
+FileSystemOperationInterface* FileSystemDispatcherHost::GetNewOperation(
+    const GURL& target_path,
     int request_id) {
   BrowserFileSystemCallbackDispatcher* dispatcher =
       new BrowserFileSystemCallbackDispatcher(this, request_id);
-  FileSystemOperation* operation = new FileSystemOperation(
-      dispatcher,
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
-      context_);
+  FileSystemOperationInterface* operation =
+      context_->CreateFileSystemOperation(
+          target_path,
+          dispatcher,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 void FileSystemDispatcherHost::UnregisterOperation(int request_id) {
   operations_.Remove(request_id);
 }