Add Worker support for FileSystem API.

chrome/browser/file_system/file_system_dispatcher_host.cc

 // Copyright (c) 2010 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 "chrome/browser/file_system/file_system_dispatcher_host.h"
 
 #include "base/file_path.h"
 #include "base/thread.h"
 #include "base/time.h"
-#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/file_system/browser_file_system_callback_dispatcher.h"
 #include "chrome/browser/file_system/file_system_host_context.h"
 #include "chrome/browser/host_content_settings_map.h"
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "googleurl/src/gurl.h"
-#include "webkit/glue/webkit_glue.h"
 
 // A class to hold an ongoing openFileSystem completion task.
 struct OpenFileSystemCompletionTask {
  public:
   static void Run(
       int request_id,
-      int routing_id,
       const std::string& name,
       const FilePath& root_path,
       FileSystemDispatcherHost* dispatcher_host) {
     // The task is self-destructed.
-    new OpenFileSystemCompletionTask(request_id, routing_id, name, root_path,
+    new OpenFileSystemCompletionTask(request_id, name, root_path,
         dispatcher_host);
   }
 
   void DidFinish(base::PlatformFileError error) {
     if (error == base::PLATFORM_FILE_OK)
       dispatcher_host_->Send(
           new ViewMsg_OpenFileSystemRequest_Complete(
-              routing_id_, request_id_, true, UTF8ToUTF16(name_),
-              webkit_glue::FilePathToWebString(root_path_)));
+              request_id_, true, name_, root_path_));
     else
       dispatcher_host_->Send(
           new ViewMsg_OpenFileSystemRequest_Complete(
-              routing_id_, request_id_, false, string16(), string16()));
+              request_id_, false, std::string(), FilePath()));
     delete this;
   }
 
  private:
   OpenFileSystemCompletionTask(
       int request_id,
-      int routing_id,
       const std::string& name,
       const FilePath& root_path,
       FileSystemDispatcherHost* dispatcher_host)
     : request_id_(request_id),
-      routing_id_(routing_id),
       name_(name),
       root_path_(root_path),
       dispatcher_host_(dispatcher_host),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     base::FileUtilProxy::CreateDirectory(
         ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE),
         root_path_, false, true, callback_factory_.NewCallback(
             &OpenFileSystemCompletionTask::DidFinish));
   }
 
   int request_id_;
-  int routing_id_;
   std::string name_;
   FilePath root_path_;
   scoped_refptr<FileSystemDispatcherHost> dispatcher_host_;
   base::ScopedCallbackFactory<OpenFileSystemCompletionTask> callback_factory_;
 };
 
 FileSystemDispatcherHost::FileSystemDispatcherHost(
     IPC::Message::Sender* sender,
     FileSystemHostContext* file_system_host_context,
     HostContentSettingsMap* host_content_settings_map)
@@ skipping 34 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_ReadMetadata, OnReadMetadata)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_Create, OnCreate)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_Exists, OnExists)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FileSystem_ReadDirectory, OnReadDirectory)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 void FileSystemDispatcherHost::OnOpenFileSystem(
-    const ViewHostMsg_OpenFileSystemRequest_Params& params) {
+    int request_id, const GURL& origin_url, fileapi::FileSystemType type,
+    int64 requested_size) {
 
   // TODO(kinuko): hook up ContentSettings cookies type checks.
 
   FilePath root_path;
   std::string name;
 
-  if (!context_->GetFileSystemRootPath(params.origin_url,
-                                       params.type,
+  if (!context_->GetFileSystemRootPath(origin_url,
+                                       type,
                                        &root_path,
                                        &name)) {
     Send(new ViewMsg_OpenFileSystemRequest_Complete(
-        params.routing_id,
-        params.request_id,
+        request_id,
         false,
-        string16(),
-        string16()));
+        std::string(),
+        FilePath()));
     return;
   }
 
   // Run the completion task that creates the root directory and sends
   // back the status code to the dispatcher.
-  OpenFileSystemCompletionTask::Run(
-      params.request_id, params.routing_id, name, root_path, this);
+  OpenFileSystemCompletionTask::Run(request_id, name, root_path, this);
 }
 
 void FileSystemDispatcherHost::OnMove(
     int request_id, const FilePath& src_path, const FilePath& dest_path) {
   if (!CheckValidFileSystemPath(src_path, request_id) ||
       !CheckValidFileSystemPath(dest_path, request_id))
     return;
 
   GetNewOperation(request_id)->Move(src_path, dest_path);
 }
@@ skipping 76 matching lines @@
       dispatcher,
       ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE));
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 void FileSystemDispatcherHost::RemoveCompletedOperation(int request_id) {
   DCHECK(operations_.Lookup(request_id));
   operations_.Remove(request_id);
 }