Add initial code to do filename munging in the FileSystem....

webkit/fileapi/file_system_path_manager_unittest.cc

 // Copyright (c) 2010 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/fileapi/file_system_path_manager.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 184 matching lines @@
                    FilePath* root_path) {
     manager->GetFileSystemRootPath(origin_url, type, create,
         callback_factory_.NewCallback(
             &FileSystemPathManagerTest::OnGetRootPath));
     MessageLoop::current()->RunAllPending();
     if (root_path)
       *root_path = root_path_;
     return root_path_callback_status_;
   }
 
+  // TODO(ericu): Add a test for the new parameter.
   bool CheckValidFileSystemPath(FileSystemPathManager* manager,
                                 const FilePath& path) {
-    return manager->CrackFileSystemPath(path, NULL, NULL, NULL);
+    return manager->CrackFileSystemPath(path, NULL, NULL, NULL, NULL);
   }
 
   FilePath data_path() { return data_dir_->path(); }
   FilePath file_system_path() {
     return data_dir_->path().Append(
         FileSystemPathManager::kFileSystemDirectory);
   }
 
  private:
   scoped_ptr<ScopedTempDir> data_dir_;
@@ skipping 130 matching lines @@
                           fileapi::kFileSystemTypeTemporary,
                           true /* create */, &root_path));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPathToVirtualPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "PathToVirtualPath #"
                  << i << " " << kPathToVirtualPathTestCases[i]);
     FilePath absolute_path = root_path.AppendASCII(
         kPathToVirtualPathTestCases[i]);
     FilePath virtual_path;
     EXPECT_TRUE(manager->CrackFileSystemPath(absolute_path, NULL, NULL,
-                                             &virtual_path));
+                                             NULL, &virtual_path));
 
     FilePath test_case_path;
     test_case_path = test_case_path.AppendASCII(
         kPathToVirtualPathTestCases[i]);
     EXPECT_EQ(test_case_path.value(), virtual_path.value());
   }
 }
 
 TEST_F(FileSystemPathManagerTest, TypeFromFileSystemPathTest) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
 
   FilePath root_path;
   fileapi::FileSystemType type;
 
   EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
                           fileapi::kFileSystemTypeTemporary,
                           true /* create */, &root_path));
   FilePath path = root_path.AppendASCII("test");
-  EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL));
+  EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL, NULL));
   EXPECT_EQ(fileapi::kFileSystemTypeTemporary, type);
 
   EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
                           fileapi::kFileSystemTypePersistent,
                           true /* create */, &root_path));
   path = root_path.AppendASCII("test");
-  EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL));
+  EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL, NULL));
   EXPECT_EQ(fileapi::kFileSystemTypePersistent, type);
 }
 
 TEST_F(FileSystemPathManagerTest, CheckValidPath) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
   FilePath root_path;
   EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
                           kFileSystemTypePersistent, true, &root_path));
 
   // The root path must be valid, but upper directories or directories
@@ skipping 22 matching lines @@
 TEST_F(FileSystemPathManagerTest, IsRestrictedName) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kIsRestrictedNameTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "IsRestrictedName #" << i << " "
                  << kIsRestrictedNameTestCases[i].name);
     FilePath name(kIsRestrictedNameTestCases[i].name);
     EXPECT_EQ(kIsRestrictedNameTestCases[i].expected_dangerous,
               manager->IsRestrictedFileName(name));
   }
 }