SyncFS: Support resolveLocalFileSystemURL on SyncFileSystem

webkit/browser/fileapi/file_system_context.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/browser/fileapi/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "url/gurl.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_options.h"
 #include "webkit/browser/fileapi/file_system_quota_client.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/isolated_file_system_backend.h"
 #include "webkit/browser/fileapi/mount_points.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/fileapi/test_file_system_backend.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
+#include "webkit/common/fileapi/file_system_info.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using quota::QuotaClient;
 
 namespace fileapi {
 
 namespace {
 
 QuotaClient* CreateQuotaClient(
     FileSystemContext* context,
     bool is_incognito) {
   return new FileSystemQuotaClient(context, is_incognito);
 }
 
 void DidOpenFileSystem(
     const FileSystemContext::OpenFileSystemCallback& callback,
     const GURL& filesystem_root,
     const std::string& filesystem_name,
     base::PlatformFileError error) {
   callback.Run(error, filesystem_name, filesystem_root);
 }
 
+void DidGetMetadataForResolveURL(
+    const base::FilePath& path,
+    const FileSystemContext::ResolveURLCallback& callback,
+    const FileSystemInfo& info,
+    base::PlatformFileError error,
+    const base::PlatformFileInfo& file_info) {
+  if (error != base::PLATFORM_FILE_OK) {
+    callback.Run(error, FileSystemInfo(), base::FilePath(), false);
+    return;
+  }
+  callback.Run(error, info, path, file_info.is_directory);
+}
+
 }  // namespace
 
 // static
 int FileSystemContext::GetPermissionPolicy(FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
     case kFileSystemTypePersistent:
     case kFileSystemTypeSyncable:
       return FILE_PERMISSION_SANDBOX;
 
@@ skipping 206 matching lines @@
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, std::string(), GURL());
     return;
   }
 
   backend->OpenFileSystem(origin_url, type, mode,
                           base::Bind(&DidOpenFileSystem, callback));
 }
 
+void FileSystemContext::ResolveURL(
+    const FileSystemURL& url,
+    const ResolveURLCallback& callback) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!callback.is_null());
+
+  FileSystemBackend* backend = GetFileSystemBackend(url.type());
+  if (!backend) {
+    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
+                 FileSystemInfo(), base::FilePath(), false);
+    return;
+  }
+
+  backend->OpenFileSystem(
+      url.origin(), url.type(),
+      OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+      base::Bind(&FileSystemContext::DidOpenFileSystemForResolveURL,
+                 this, url, callback));
+}
+
 void FileSystemContext::DeleteFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const DeleteFileSystemCallback& callback) {
   DCHECK(origin_url == origin_url.GetOrigin());
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     return;
   }
@@ skipping 129 matching lines @@
       if (cracked.is_valid())
         break;
     }
     if (cracked == current)
       break;
     current = cracked;
   }
   return current;
 }
 
-void FileSystemContext::RegisterBackend(
-    FileSystemBackend* backend) {
+void FileSystemContext::RegisterBackend(FileSystemBackend* backend) {
   const FileSystemType mount_types[] = {
     kFileSystemTypeTemporary,
     kFileSystemTypePersistent,
     kFileSystemTypeIsolated,
     kFileSystemTypeExternal,
   };
   // Register file system backends for public mount types.
   for (size_t j = 0; j < ARRAYSIZE_UNSAFE(mount_types); ++j) {
     if (backend->CanHandleType(mount_types[j])) {
       const bool inserted = backend_map_.insert(
           std::make_pair(mount_types[j], backend)).second;
       DCHECK(inserted);
     }
   }
   // Register file system backends for internal types.
   for (int t = kFileSystemInternalTypeEnumStart + 1;
        t < kFileSystemInternalTypeEnumEnd; ++t) {
     FileSystemType type = static_cast<FileSystemType>(t);
     if (backend->CanHandleType(type)) {
       const bool inserted = backend_map_.insert(
           std::make_pair(type, backend)).second;
       DCHECK(inserted);
     }
   }
 }
 
+void FileSystemContext::DidOpenFileSystemForResolveURL(
+    const FileSystemURL& url,
+    const FileSystemContext::ResolveURLCallback& callback,
+    const GURL& filesystem_root,
+    const std::string& filesystem_name,
+    base::PlatformFileError error) {
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+
+  if (error != base::PLATFORM_FILE_OK) {
+    callback.Run(error, FileSystemInfo(), base::FilePath(), false);
+    return;
+  }
+
+  fileapi::FileSystemInfo info(
+      filesystem_name, filesystem_root, url.mount_type());
+
+  // Extract the virtual path not containing a filesystem type part from |url|.
+  base::FilePath parent =
+      base::FilePath::FromUTF8Unsafe(filesystem_root.path());
+  base::FilePath child = base::FilePath::FromUTF8Unsafe(url.ToGURL().path());
+  base::FilePath path;
+  bool result = parent.AppendRelativePath(child, &path);
+  DCHECK(result);
+
+  operation_runner()->GetMetadata(
+      url, base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
+}
+
 }  // namespace fileapi