New FileSystemURL cracking

webkit/fileapi/media/native_media_file_util_unittest.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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
@@ skipping 117 matching lines @@
   void TearDown() {
     isolated_context()->RemoveReference(filesystem_id_);
     file_system_context_ = NULL;
   }
 
  protected:
   FileSystemContext* file_system_context() {
     return file_system_context_.get();
   }
 
+  FileSystemURL CreateURL(const FilePath::CharType* test_case_path) {
+    return file_system_context_->CreateCrackedFileSystemURL(
+        origin(),
+        fileapi::kFileSystemTypeIsolated,
+        GetVirtualPath(test_case_path));
+  }
+
   IsolatedContext* isolated_context() {
     return IsolatedContext::GetInstance();
   }
 
   FilePath root_path() {
     return data_dir_.path().Append(FPL("Media Directory"));
   }
 
+  FilePath GetVirtualPath(const FilePath::CharType* test_case_path) {
+    return FilePath::FromUTF8Unsafe(filesystem_id_).
+               Append(FPL("Media Directory")).
+               Append(FilePath(test_case_path));
+  }
+
   FileSystemFileUtil* file_util() {
     return file_util_;
   }
 
   GURL origin() {
     return GURL("http://example.com");
   }
 
   fileapi::FileSystemType type() {
     return kFileSystemTypeNativeMedia;
@@ skipping 14 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NativeMediaFileUtilTest);
 };
 
 TEST_F(NativeMediaFileUtilTest, DirectoryExistsAndFileExistsFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
 
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-    FilePath path = root_path().Append(kFilteringTestCases[i].path);
-    FileSystemURL url(origin(), type(), path);
+    FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
     FileSystemOperation* operation = NewOperation(url);
 
     base::PlatformFileError expectation =
         kFilteringTestCases[i].visible ?
         base::PLATFORM_FILE_OK :
         base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
     std::string test_name =
         base::StringPrintf("DirectoryExistsAndFileExistsFiltering %" PRIuS, i);
     if (kFilteringTestCases[i].is_directory) {
       operation->DirectoryExists(
           url, base::Bind(&ExpectEqHelper, test_name, expectation));
     } else {
       operation->FileExists(
           url, base::Bind(&ExpectEqHelper, test_name, expectation));
     }
     MessageLoop::current()->RunUntilIdle();
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, ReadDirectoryFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
 
   std::set<FilePath::StringType> content;
-  FileSystemURL url(origin(), type(), root_path());
+  FileSystemURL url = CreateURL(FPL(""));
   bool completed = false;
   NewOperation(url)->ReadDirectory(
       url, base::Bind(&DidReadDirectory, &content, &completed));
   MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(completed);
   EXPECT_EQ(5u, content.size());
 
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
     FilePath::StringType name =
         FilePath(kFilteringTestCases[i].path).BaseName().value();
     std::set<FilePath::StringType>::const_iterator found = content.find(name);
     EXPECT_EQ(kFilteringTestCases[i].visible, found != content.end());
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CreateFileAndCreateDirectoryFiltering) {
   // Run the loop twice. The second loop attempts to create files that are
   // pre-existing. Though the result should be the same.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "CreateFileAndCreateDirectoryFiltering run %d, test %" PRIuS,
           loop_count, i);
       base::PlatformFileError expectation =
           kFilteringTestCases[i].visible ?
           base::PLATFORM_FILE_OK :
           base::PLATFORM_FILE_ERROR_SECURITY;
       if (kFilteringTestCases[i].is_directory) {
         operation->CreateDirectory(
             url, false, false,
             base::Bind(&ExpectEqHelper, test_name, expectation));
       } else {
         operation->CreateFile(
             url, false, base::Bind(&ExpectEqHelper, test_name, expectation));
       }
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CopySourceFiltering) {
   FilePath dest_path = root_path().AppendASCII("dest");
-  FileSystemURL dest_url(origin(), type(), dest_path);
+  FileSystemURL dest_url = CreateURL(FPL("dest"));
 
   // Run the loop twice. The first run has no source files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       // Always start with an empty destination directory.
       // Copying to a non-empty destination directory is an invalid operation.
       ASSERT_TRUE(file_util::Delete(dest_path, true));
       ASSERT_TRUE(file_util::CreateDirectory(dest_path));
 
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "CopySourceFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
         expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot copy a visible file to a directory.
         expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
@@ skipping 14 matching lines @@
       // directories and create new ones that should pre-exist.
       ASSERT_TRUE(file_util::Delete(root_path(), true));
       ASSERT_TRUE(file_util::CreateDirectory(root_path()));
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
 
     // Always create a dummy source data file.
     FilePath src_path = root_path().AppendASCII("foo.jpg");
-    FileSystemURL src_url(origin(), type(), src_path);
+    FileSystemURL src_url = CreateURL(FPL("foo.jpg"));
     static const char kDummyData[] = "dummy";
     ASSERT_TRUE(file_util::WriteFile(src_path, kDummyData, strlen(kDummyData)));
 
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "CopyDestFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation;
       if (loop_count == 0) {
         // These directories do not exist in this case, so Copy() will not
         // treat them as directories. Thus invalidating these test cases.
         if (kFilteringTestCases[i].is_directory)
           continue;
         // If the destination path does not exist and is not visible, then
@@ skipping 18 matching lines @@
       }
       operation->Copy(
           src_url, url, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, MoveSourceFiltering) {
   FilePath dest_path = root_path().AppendASCII("dest");
-  FileSystemURL dest_url(origin(), type(), dest_path);
+  FileSystemURL dest_url = CreateURL(FPL("dest"));
 
   // Run the loop twice. The first run has no source files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       // Always start with an empty destination directory.
       // Moving to a non-empty destination directory is an invalid operation.
       ASSERT_TRUE(file_util::Delete(dest_path, true));
       ASSERT_TRUE(file_util::CreateDirectory(dest_path));
 
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "MoveSourceFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // If the source does not exist or is not visible.
         expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       } else if (!kFilteringTestCases[i].is_directory) {
         // Cannot move a visible file to a directory.
         expectation = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
@@ skipping 15 matching lines @@
       ASSERT_TRUE(file_util::Delete(root_path(), true));
       ASSERT_TRUE(file_util::CreateDirectory(root_path()));
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
 
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       // Create the source file for every test case because it might get moved.
       FilePath src_path = root_path().AppendASCII("foo.jpg");
-      FileSystemURL src_url(origin(), type(), src_path);
+      FileSystemURL src_url = CreateURL(FPL("foo.jpg"));
       static const char kDummyData[] = "dummy";
       ASSERT_TRUE(
           file_util::WriteFile(src_path, kDummyData, strlen(kDummyData)));
 
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "MoveDestFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation;
       if (loop_count == 0) {
         // These directories do not exist in this case, so Move() will not
         // treat them as directories. Thus invalidating these test cases.
         if (kFilteringTestCases[i].is_directory)
           continue;
         // If the destination path does not exist and is not visible, then
@@ skipping 25 matching lines @@
 
 TEST_F(NativeMediaFileUtilTest, GetMetadataFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "GetMetadataFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Cannot get metadata from files that do not exist or are not visible.
         expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       }
       operation->GetMetadata(url,
                              base::Bind(&ExpectMetadataEqHelper,
                                         test_name,
                                         expectation,
                                         kFilteringTestCases[i].is_directory));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, RemoveFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "RemoveFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Cannot remove files that do not exist or are not visible.
         expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       }
       operation->Remove(
           url, false, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, TruncateFiltering) {
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "TruncateFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Cannot truncate files that do not exist or are not visible.
         expectation = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       } else if (kFilteringTestCases[i].is_directory) {
         // Cannot truncate directories.
         expectation = base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
       }
       operation->Truncate(
           url, 0, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, TouchFileFiltering) {
   base::Time time = base::Time::Now();
 
   // Run the loop twice. The first run has no files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-      FileSystemURL root_url(origin(), type(), root_path());
+      FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
-      FilePath path = root_path().Append(kFilteringTestCases[i].path);
-      FileSystemURL url(origin(), type(), path);
+      FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
       std::string test_name = base::StringPrintf(
           "TouchFileFiltering run %d test %" PRIuS, loop_count, i);
       base::PlatformFileError expectation = base::PLATFORM_FILE_OK;
       if (loop_count == 0 || !kFilteringTestCases[i].visible) {
         // Files do not exists. Touch fails.
         expectation = base::PLATFORM_FILE_ERROR_FAILED;
       }
       operation->TouchFile(
           url, time, time, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }