More filesystem cleanup: convert URL-encoded-as-FilePath to actual URL, where

content/browser/file_system/file_system_dispatcher_host.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/threading/thread.h"
@@ skipping 38 matching lines @@
         request_id_, info, platform_path));
   }
 
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries, bool has_more) {
     dispatcher_host_->Send(new FileSystemMsg_DidReadDirectory(
         request_id_, entries, has_more));
   }
 
   virtual void DidOpenFileSystem(const std::string& name,
-                                 const FilePath& path) {
+                                 const GURL& root) {
     dispatcher_host_->Send(
-        new FileSystemMsg_OpenComplete(request_id_, !path.empty(), name, path));
+        new FileSystemMsg_OpenComplete(
+            request_id_, root.is_valid(), name, root));
   }
 
   virtual void DidFail(base::PlatformFileError error_code) {
     dispatcher_host_->Send(new FileSystemMsg_DidFail(request_id_, error_code));
   }
 
   virtual void DidWrite(int64 bytes, bool complete) {
     dispatcher_host_->Send(new FileSystemMsg_DidWrite(
         request_id_, bytes, complete));
   }
@@ skipping 57 matching lines @@
   ContentSetting content_setting =
       host_content_settings_map_->GetContentSetting(
           origin_url, CONTENT_SETTINGS_TYPE_COOKIES, "");
   DCHECK((content_setting == CONTENT_SETTING_ALLOW) ||
          (content_setting == CONTENT_SETTING_BLOCK) ||
          (content_setting == CONTENT_SETTING_SESSION_ONLY));
   if (content_setting == CONTENT_SETTING_BLOCK) {
     // TODO(kinuko): Need to notify the UI thread to indicate that
     // there's a blocked content.
     Send(new FileSystemMsg_OpenComplete(
-        request_id, false, std::string(), FilePath()));
+        request_id, false, std::string(), GURL()));
     return;
   }
 
   GetNewOperation(request_id)->OpenFileSystem(origin_url, type, create);
 }
 
 void FileSystemDispatcherHost::OnMove(
-    int request_id, const FilePath& src_path, const FilePath& dest_path) {
+    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 FilePath& src_path, const FilePath& dest_path) {
+    int request_id, const GURL& src_path, const GURL& dest_path) {
   GetNewOperation(request_id)->Copy(src_path, dest_path);
 }
 
 void FileSystemDispatcherHost::OnRemove(
-    int request_id, const FilePath& path, bool recursive) {
+    int request_id, const GURL& path, bool recursive) {
   GetNewOperation(request_id)->Remove(path, recursive);
 }
 
 void FileSystemDispatcherHost::OnReadMetadata(
-    int request_id, const FilePath& path) {
+    int request_id, const GURL& path) {
   GetNewOperation(request_id)->GetMetadata(path);
 }
 
 void FileSystemDispatcherHost::OnCreate(
-    int request_id, const FilePath& path, bool exclusive,
+    int request_id, const GURL& path, bool exclusive,
     bool is_directory, bool recursive) {
   if (is_directory)
     GetNewOperation(request_id)->CreateDirectory(path, exclusive, recursive);
   else
     GetNewOperation(request_id)->CreateFile(path, exclusive);
 }
 
 void FileSystemDispatcherHost::OnExists(
-    int request_id, const FilePath& path, bool is_directory) {
+    int request_id, const GURL& path, bool is_directory) {
   if (is_directory)
     GetNewOperation(request_id)->DirectoryExists(path);
   else
     GetNewOperation(request_id)->FileExists(path);
 }
 
 void FileSystemDispatcherHost::OnReadDirectory(
-    int request_id, const FilePath& path) {
+    int request_id, const GURL& path) {
   GetNewOperation(request_id)->ReadDirectory(path);
 }
 
 void FileSystemDispatcherHost::OnWrite(
     int request_id,
-    const FilePath& path,
+    const GURL& path,
     const GURL& blob_url,
     int64 offset) {
   GetNewOperation(request_id)->Write(
       request_context_, path, blob_url, offset);
 }
 
 void FileSystemDispatcherHost::OnTruncate(
     int request_id,
-    const FilePath& path,
+    const GURL& path,
     int64 length) {
   GetNewOperation(request_id)->Truncate(path, length);
 }
 
 void FileSystemDispatcherHost::OnTouchFile(
     int request_id,
-    const FilePath& path,
+    const GURL& path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   GetNewOperation(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(
@@ skipping 19 matching lines @@
       context_,
       NULL);
   operations_.AddWithID(operation, request_id);
   return operation;
 }
 
 void FileSystemDispatcherHost::UnregisterOperation(int request_id) {
   DCHECK(operations_.Lookup(request_id));
   operations_.Remove(request_id);
 }