Add 1st cut of FileSystemUsageTracker that tracks the usage changes in FileSystem API.

webkit/fileapi/file_system_path_manager.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/file_util.h"
 #include "base/rand_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 59 matching lines @@
   static const FilePath::CharType letters[] = FILE_PATH_LITERAL(
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
   FilePath::StringType unique(kFileSystemUniqueNamePrefix);
   for (int i = 0; i < kFileSystemUniqueLength; ++i)
     unique += letters[base::RandInt(0, arraysize(letters) - 2)];
   return unique;
 }
 
 static const char kExtensionScheme[] = "chrome-extension";
 
+inline std::string GetFileSystemTypeString(fileapi::FileSystemType type) {
+  if (type == fileapi::kFileSystemTypeTemporary)
+    return fileapi::FileSystemPathManager::kTemporaryName;
+  else if (type == fileapi::kFileSystemTypePersistent)
+    return fileapi::FileSystemPathManager::kPersistentName;
+  return std::string();
+}
+
 }  // anonymous namespace
 
 class FileSystemPathManager::GetFileSystemRootPathTask
     : public base::RefCountedThreadSafe<
         FileSystemPathManager::GetFileSystemRootPathTask> {
  public:
   GetFileSystemRootPathTask(
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
       const std::string& name,
       FileSystemPathManager::GetRootPathCallback* callback)
@@ skipping 101 matching lines @@
     // TODO(kinuko): return an isolated temporary directory.
     callback->Run(false, FilePath(), std::string());
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
     callback->Run(false, FilePath(), std::string());
     return;
   }
 
-  if (type != fileapi::kFileSystemTypeTemporary &&
-      type != fileapi::kFileSystemTypePersistent) {
-    LOG(WARNING) << "Unknown filesystem type is requested:" << type;
+  FilePath origin_base_path = GetFileSystemBaseDirectoryForOriginAndType(
+      base_path(), origin_url, type);
+  if (origin_base_path.empty()) {
     callback->Run(false, FilePath(), std::string());
     return;
   }
 
-  std::string storage_identifier = GetStorageIdentifierFromURL(origin_url);
-
-  std::string type_string;
-  if (type == fileapi::kFileSystemTypeTemporary)
-    type_string = kTemporaryName;
-  else if (type == fileapi::kFileSystemTypePersistent)
-    type_string = kPersistentName;
-  DCHECK(!type_string.empty());
-
-  FilePath origin_base_path = base_path_.AppendASCII(storage_identifier)
-                                        .AppendASCII(type_string);
-  std::string name = storage_identifier + ":" + type_string;
-
   scoped_refptr<GetFileSystemRootPathTask> task(
       new GetFileSystemRootPathTask(file_message_loop_,
-                                    name, callback.release()));
+                                    GetFileSystemName(origin_url, type),
+                                    callback.release()));
   task->Start(origin_url, origin_base_path, create);
 }
 
 bool FileSystemPathManager::CrackFileSystemPath(
     const FilePath& path, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path) const {
   // Any paths that includes parent references are considered invalid.
   if (path.ReferencesParent())
     return false;
 
@@ skipping 85 matching lines @@
 }
 
 bool FileSystemPathManager::IsAllowedScheme(const GURL& url) const {
   // Basically we only accept http or https. We allow file:// URLs
   // only if --allow-file-access-from-files flag is given.
   return url.SchemeIs("http") || url.SchemeIs("https") ||
          url.SchemeIs(kExtensionScheme) ||
          (url.SchemeIsFile() && allow_file_access_from_files_);
 }
 
+// static
+std::string FileSystemPathManager::GetFileSystemName(
+    const GURL& origin_url, fileapi::FileSystemType type) {
+  return GetStorageIdentifierFromURL(origin_url)
+      .append(":").append(GetFileSystemTypeString(type));
+}
+
+// static
 std::string FileSystemPathManager::GetStorageIdentifierFromURL(
     const GURL& url) {
   WebKit::WebSecurityOrigin web_security_origin =
       WebKit::WebSecurityOrigin::createFromString(UTF8ToUTF16(url.spec()));
   return web_security_origin.databaseIdentifier().utf8();
 }
 
+// static
+FilePath FileSystemPathManager::GetFileSystemBaseDirectoryForOriginAndType(
+    const FilePath& base_path, const GURL& origin_url,
+    fileapi::FileSystemType type) {
+  if (!origin_url.is_valid())
+    return FilePath();
+  std::string type_string = GetFileSystemTypeString(type);
+  if (type_string.empty()) {
+    LOG(WARNING) << "Unknown filesystem type is requested:" << type;
+    return FilePath();
+  }
+  return base_path.AppendASCII(GetStorageIdentifierFromURL(origin_url))
+                  .AppendASCII(type_string);
+}
+
 }  // namespace fileapi
 
 COMPILE_ASSERT(int(WebFileSystem::TypeTemporary) == \
                int(fileapi::kFileSystemTypeTemporary), mismatching_enums);
 COMPILE_ASSERT(int(WebFileSystem::TypePersistent) == \
                int(fileapi::kFileSystemTypePersistent), mismatching_enums);