New FileSystemURL cracking

webkit/tools/test_shell/simple_file_system.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 105 matching lines @@
 
   GURL origin_url(frame->document().securityOrigin().toString());
   file_system_context_->DeleteFileSystem(
       origin_url, static_cast<fileapi::FileSystemType>(type),
       DeleteFileSystemHandler(callbacks));
 }
 
 void SimpleFileSystem::move(
     const WebURL& src_path,
     const WebURL& dest_path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL src_url(src_path);
-  FileSystemURL dest_url(dest_path);
+  FileSystemURL src_url(file_system_context()->CrackURL(src_path));
+  FileSystemURL dest_url(file_system_context()->CrackURL(dest_path));
   if (!HasFilePermission(src_url, FILE_PERMISSION_WRITE) ||
       !HasFilePermission(dest_url, FILE_PERMISSION_CREATE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(src_url)->Move(src_url, dest_url,
                                  FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::copy(
     const WebURL& src_path, const WebURL& dest_path,
     WebFileSystemCallbacks* callbacks) {
-  FileSystemURL src_url(src_path);
-  FileSystemURL dest_url(dest_path);
+  FileSystemURL src_url(file_system_context()->CrackURL(src_path));
+  FileSystemURL dest_url(file_system_context()->CrackURL(dest_path));
   if (!HasFilePermission(src_url, FILE_PERMISSION_READ) ||
       !HasFilePermission(dest_url, FILE_PERMISSION_CREATE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(src_url)->Copy(src_url, dest_url,
                                  FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::remove(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_WRITE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->Remove(url, false /* recursive */,
                                FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::removeRecursively(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_WRITE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->Remove(url, true /* recursive */,
                                FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::readMetadata(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_READ)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->GetMetadata(url, GetMetadataHandler(callbacks));
 }
 
 void SimpleFileSystem::createFile(
     const WebURL& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_CREATE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->CreateFile(url, exclusive, FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::createDirectory(
     const WebURL& path, bool exclusive, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_CREATE)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->CreateDirectory(url, exclusive, false,
                                         FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::fileExists(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_READ)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->FileExists(url, FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::directoryExists(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_READ)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->DirectoryExists(url, FinishHandler(callbacks));
 }
 
 void SimpleFileSystem::readDirectory(
     const WebURL& path, WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_READ)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->ReadDirectory(url, ReadDirectoryHandler(callbacks));
 }
 
 WebFileWriter* SimpleFileSystem::createFileWriter(
     const WebURL& path, WebFileWriterClient* client) {
   return new SimpleFileWriter(path, client, file_system_context_.get());
 }
 
 void SimpleFileSystem::createSnapshotFileAndReadMetadata(
     const WebURL& blobURL,
     const WebURL& path,
     WebFileSystemCallbacks* callbacks) {
-  FileSystemURL url(path);
+  FileSystemURL url(file_system_context()->CrackURL(path));
   if (!HasFilePermission(url, FILE_PERMISSION_READ)) {
     callbacks->didFail(WebKit::WebFileErrorSecurity);
     return;
   }
   GetNewOperation(url)->CreateSnapshotFile(
       url, SnapshotFileHandler(blobURL, callbacks));
 }
 
 // static
 void SimpleFileSystem::InitializeOnIOThread(
@@ skipping 135 matching lines @@
     const FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   DCHECK(g_io_thread);
   if (result == base::PLATFORM_FILE_OK) {
     g_io_thread->PostTask(
         FROM_HERE,
         base::Bind(&RegisterBlob, blob_url, platform_path));
   }
   DidGetMetadata(callbacks, result, info, platform_path);
 }