Add RegisterMountPointProvider and TestMountPointProvider for testing

webkit/fileapi/file_system_util.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/fileapi/file_system_util.h"
 
 #include "build/build_config.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "webkit/fileapi/file_system_types.h"
 
 namespace fileapi {
 
 const char kPersistentDir[] = "/persistent";
 const char kTemporaryDir[] = "/temporary";
 const char kIsolatedDir[] = "/isolated";
 const char kExternalDir[] = "/external";
+const char kTestDir[] = "/test";
 
 const char kPersistentName[] = "Persistent";
 const char kTemporaryName[] = "Temporary";
 const char kIsolatedName[] = "Isolated";
 const char kExternalName[] = "External";
+const char kTestName[] = "Test";
 
 bool CrackFileSystemURL(const GURL& url, GURL* origin_url, FileSystemType* type,
                         FilePath* file_path) {
   GURL origin;
   FileSystemType file_system_type = kFileSystemTypeUnknown;
 
   if (!url.is_valid() || !url.SchemeIsFileSystem())
     return false;
   DCHECK(url.inner_url());
 
   std::string inner_path = url.inner_url()->path();
 
   const struct {
     FileSystemType type;
     const char* dir;
   } kValidTypes[] = {
     { kFileSystemTypePersistent, kPersistentDir },
     { kFileSystemTypeTemporary, kTemporaryDir },
     { kFileSystemTypeIsolated, kIsolatedDir },
     { kFileSystemTypeExternal, kExternalDir },
+    { kFileSystemTypeTest, kTestDir },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kValidTypes); ++i) {
     if (StartsWithASCII(inner_path, kValidTypes[i].dir, true)) {
       file_system_type = kValidTypes[i].type;
       break;
     }
   }
 
   if (file_system_type == kFileSystemTypeUnknown)
     return false;
@@ skipping 77 matching lines @@
   switch (type) {
   case kFileSystemTypeTemporary:
     url += (kTemporaryDir + 1);  // We don't want the leading slash.
     return GURL(url + "/");
   case kFileSystemTypePersistent:
     url += (kPersistentDir + 1);  // We don't want the leading slash.
     return GURL(url + "/");
   case kFileSystemTypeExternal:
     url += (kExternalDir + 1);  // We don't want the leading slash.
     return GURL(url + "/");
+  case kFileSystemTypeTest:
+    url += (kTestDir + 1);  // We don't want the leading slash.
+    return GURL(url + "/");
   case kFileSystemTypeIsolated:
     // Falling through; we won't call this for isolated filesystems.
   case kFileSystemTypeUnknown:
     NOTREACHED();
   }
   NOTREACHED();
   return GURL();
 }
 
 std::string GetFileSystemName(const GURL& origin_url, FileSystemType type) {
@@ skipping 50 matching lines @@
 }
 
 std::string GetFileSystemTypeString(FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
       return fileapi::kTemporaryName;
     case kFileSystemTypePersistent:
       return fileapi::kPersistentName;
     case kFileSystemTypeExternal:
       return fileapi::kExternalName;
+    case kFileSystemTypeTest:
+      return fileapi::kTestName;
     case kFileSystemTypeUnknown:
     default:
       return std::string();
   }
 }
 
 std::string FilePathToString(const FilePath& file_path) {
 #if defined(OS_WIN)
   return UTF16ToUTF8(file_path.value());
 #elif defined(OS_POSIX)
   return file_path.value();
 #endif
 }
 
 FilePath StringToFilePath(const std::string& file_path_string) {
 #if defined(OS_WIN)
   return FilePath(UTF8ToUTF16(file_path_string));
 #elif defined(OS_POSIX)
   return FilePath(file_path_string);
 #endif
 }
 
 }  // namespace fileapi