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

webkit/tools/test_shell/simple_file_writer.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 "webkit/tools/test_shell/simple_file_writer.h"
 
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
@@ skipping 27 matching lines @@
         file_system_context_(file_system_context) {
     // The IO thread needs to be running for this class to work.
     SimpleResourceLoaderBridge::EnsureIOThread();
     io_thread_ = SimpleResourceLoaderBridge::GetIoThread();
     main_thread_ = base::MessageLoopProxy::CreateForCurrentThread();
   }
 
   virtual ~IOThreadProxy() {
   }
 
-  void Truncate(const FilePath& path, int64 offset) {
+  void Truncate(const GURL& path, int64 offset) {
     if (!io_thread_->BelongsToCurrentThread()) {
       io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &IOThreadProxy::Truncate, path, offset));
       return;
     }
     DCHECK(!operation_);
     operation_ = GetNewOperation();
     operation_->Truncate(path, offset);
   }
 
-  void Write(const FilePath& path, const GURL& blob_url, int64 offset) {
+  void Write(const GURL& path, const GURL& blob_url, int64 offset) {
     if (!io_thread_->BelongsToCurrentThread()) {
       io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &IOThreadProxy::Write, path, blob_url, offset));
       return;
     }
     DCHECK(request_context_);
     DCHECK(!operation_);
     operation_ = GetNewOperation();
     operation_->Write(request_context_, path, blob_url, offset);
   }
@@ skipping 41 matching lines @@
     }
 
     virtual void DidReadDirectory(
         const std::vector<base::FileUtilProxy::Entry>& entries,
         bool has_more) {
       NOTREACHED();
     }
 
     virtual void DidOpenFileSystem(
         const std::string& name,
-        const FilePath& root_path) {
+        const GURL& root) {
       NOTREACHED();
     }
 
     scoped_refptr<IOThreadProxy> proxy_;
   };
 
   FileSystemOperation* GetNewOperation() {
     // The FileSystemOperation takes ownership of the CallbackDispatcher.
     return new FileSystemOperation(new CallbackDispatcher(this),
                                    io_thread_, file_system_context_.get(),
@@ skipping 42 matching lines @@
   base::WeakPtr<SimpleFileWriter> simple_writer_;
 
   // Only used on the io thread.
   FileSystemOperation* operation_;
 
   scoped_refptr<FileSystemContext> file_system_context_;
 };
 
 
 SimpleFileWriter::SimpleFileWriter(
-    const WebString& path,
+    const GURL& path,
     WebFileWriterClient* client,
     FileSystemContext* file_system_context)
   : WebFileWriterBase(path, client),
     io_thread_proxy_(new IOThreadProxy(AsWeakPtr(), file_system_context)) {
 }
 
 SimpleFileWriter::~SimpleFileWriter() {
 }
 
-void SimpleFileWriter::DoTruncate(const FilePath& path, int64 offset) {
+void SimpleFileWriter::DoTruncate(const GURL& path, int64 offset) {
   io_thread_proxy_->Truncate(path, offset);
 }
 
 void SimpleFileWriter::DoWrite(
-    const FilePath& path, const GURL& blob_url, int64 offset) {
+    const GURL& path, const GURL& blob_url, int64 offset) {
   io_thread_proxy_->Write(path, blob_url, offset);
 }
 
 void SimpleFileWriter::DoCancel() {
   io_thread_proxy_->Cancel();
 }