String->URL cleanup, chromium-side.

webkit/tools/test_shell/simple_file_system.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_system.h"
 
 #include "base/file_path.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystemCallbacks.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystemEntry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVector.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_file_writer.h"
 
 using base::WeakPtr;
 
 using WebKit::WebFileInfo;
 using WebKit::WebFileSystem;
 using WebKit::WebFileSystemCallbacks;
 using WebKit::WebFileSystemEntry;
 using WebKit::WebFileWriter;
 using WebKit::WebFileWriterClient;
 using WebKit::WebFrame;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebString;
+using WebKit::WebURL;
 using WebKit::WebVector;
 
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
 
 namespace {
 
 class SimpleFileSystemCallbackDispatcher
@@ skipping 48 matching lines @@
         web_entries_vector;
     callbacks_->didReadDirectory(web_entries, has_more);
   }
 
   virtual void DidOpenFileSystem(
       const std::string& name, const GURL& root) {
     DCHECK(file_system_);
     if (!root.is_valid())
       callbacks_->didFail(WebKit::WebFileErrorSecurity);
     else
-      callbacks_->didOpenFileSystem(
-          WebString::fromUTF8(name), WebString::fromUTF8(root.spec()));
+      //TODO(ericu): This should keep making the old string call for now,
+      //then we'll add the new call to webkit, then we'll convert this call,
+      //then we'll remove the old call from webkit.
+      callbacks_->didOpenFileSystem(WebString::fromUTF8(name), WebURL(root));
   }
 
   virtual void DidFail(base::PlatformFileError error_code) {
     DCHECK(file_system_);
     callbacks_->didFail(
         webkit_glue::PlatformFileErrorToWebFileError(error_code));
   }
 
   virtual void DidWrite(int64, bool) {
     NOTREACHED();
@@ skipping 46 matching lines @@
   else {
     // Unknown type filesystem is requested.
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
 
   GURL origin_url(frame->securityOrigin().toString());
   GetNewOperation(callbacks)->OpenFileSystem(origin_url, type, create);
 }
 
+void SimpleFileSystem::move(const WebString& src_path,
+                             const WebString& dest_path,

[kinuko, 2011/04/28 12:43:31]

nit: indent

+                             WebFileSystemCallbacks* callbacks) {
+  move(WebURL(GURL(src_path)), WebURL(GURL(dest_path)), callbacks);
+}
+
+void SimpleFileSystem::copy(const WebString& src_path,
+                             const WebString& dest_path,
+                             WebFileSystemCallbacks* callbacks) {
+  copy(WebURL(GURL(src_path)), WebURL(GURL(dest_path)), callbacks);
+}
+
+void SimpleFileSystem::remove(const WebString& path,
+                               WebFileSystemCallbacks* callbacks) {
+  remove(WebURL(GURL(path)), callbacks);
+}
+
+void SimpleFileSystem::removeRecursively(const WebString& path,
+                                          WebFileSystemCallbacks* callbacks) {
+  removeRecursively(WebURL(GURL(path)), callbacks);
+}
+
+void SimpleFileSystem::readMetadata(const WebString& path,
+                                     WebFileSystemCallbacks* callbacks) {
+  readMetadata(WebURL(GURL(path)), callbacks);
+}
+
+void SimpleFileSystem::createFile(const WebString& path,
+                                   bool exclusive,
+                                   WebFileSystemCallbacks* callbacks) {
+  createFile(WebURL(GURL(path)), exclusive, callbacks);
+}
+
+void SimpleFileSystem::createDirectory(const WebString& path,
+                                        bool exclusive,
+                                        WebFileSystemCallbacks* callbacks) {
+  createDirectory(WebURL(GURL(path)), exclusive, callbacks);
+}
+
+void SimpleFileSystem::fileExists(const WebString& path,
+                                   WebFileSystemCallbacks* callbacks) {
+  fileExists(WebURL(GURL(path)), callbacks);
+}
+
+void SimpleFileSystem::directoryExists(const WebString& path,
+                                        WebFileSystemCallbacks* callbacks) {
+  directoryExists(WebURL(GURL(path)), callbacks);
+}
+
+void SimpleFileSystem::readDirectory(const WebString& path,
+                                      WebFileSystemCallbacks* callbacks) {
+  readDirectory(WebURL(GURL(path)), callbacks);
+}
+
+WebKit::WebFileWriter* SimpleFileSystem::createFileWriter(
+    const WebString& path, WebKit::WebFileWriterClient* client) {
+  return createFileWriter(WebURL(GURL(path)), client);
+}
+
 void SimpleFileSystem::move(
-    const WebString& src_path,
-    const WebString& dest_path, WebFileSystemCallbacks* callbacks) {
+    const WebURL& src_path,
+    const WebURL& dest_path, WebFileSystemCallbacks* callbacks) {
   GetNewOperation(callbacks)->Move(GURL(src_path), GURL(dest_path));
 }
 
 void SimpleFileSystem::copy(
-    const WebString& src_path, const WebString& dest_path,
+    const WebURL& src_path, const WebURL& dest_path,
     WebFileSystemCallbacks* callbacks) {
   GetNewOperation(callbacks)->Copy(GURL(src_path), GURL(dest_path));
 }
 
 void SimpleFileSystem::remove(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->Remove(GURL(path), false /* recursive */);
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->Remove(path, false /* recursive */);
 }
 
 void SimpleFileSystem::removeRecursively(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->Remove(GURL(path), true /* recursive */);
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->Remove(path, true /* recursive */);
 }
 
 void SimpleFileSystem::readMetadata(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->GetMetadata(GURL(path));
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->GetMetadata(path);
 }
 
 void SimpleFileSystem::createFile(
-    const WebString& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->CreateFile(GURL(path), exclusive);
+    const WebURL& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->CreateFile(path, exclusive);
 }
 
 void SimpleFileSystem::createDirectory(
-    const WebString& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->CreateDirectory(GURL(path), exclusive, false);
+    const WebURL& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->CreateDirectory(path, exclusive, false);
 }
 
 void SimpleFileSystem::fileExists(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->FileExists(GURL(path));
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->FileExists(path);
 }
 
 void SimpleFileSystem::directoryExists(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->DirectoryExists(GURL(path));
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->DirectoryExists(path);
 }
 
 void SimpleFileSystem::readDirectory(
-    const WebString& path, WebFileSystemCallbacks* callbacks) {
-  GetNewOperation(callbacks)->ReadDirectory(GURL(path));
+    const WebURL& path, WebFileSystemCallbacks* callbacks) {
+  GetNewOperation(callbacks)->ReadDirectory(path);
 }
 
 WebFileWriter* SimpleFileSystem::createFileWriter(
-    const WebString& path, WebFileWriterClient* client) {
-  return new SimpleFileWriter(GURL(path), client, file_system_context_.get());
+    const WebURL& path, WebFileWriterClient* client) {
+  return new SimpleFileWriter(path, client, file_system_context_.get());
 }
 
 FileSystemOperation* SimpleFileSystem::GetNewOperation(
     WebFileSystemCallbacks* callbacks) {
   SimpleFileSystemCallbackDispatcher* dispatcher =
       new SimpleFileSystemCallbackDispatcher(AsWeakPtr(), callbacks);
   FileSystemOperation* operation = new FileSystemOperation(
       dispatcher, base::MessageLoopProxy::CreateForCurrentThread(),
       file_system_context_.get(), NULL);
   return operation;
 }