Home | History | Annotate | Download | only in fileapi 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "webkit/browser/fileapi/file_system_context.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/single_thread_task_runner.h"
      9 #include "base/stl_util.h"
     10 #include "base/task_runner_util.h"
     11 #include "net/url_request/url_request.h"
     12 #include "url/gurl.h"
     13 #include "webkit/browser/blob/file_stream_reader.h"
     14 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
     15 #include "webkit/browser/fileapi/external_mount_points.h"
     16 #include "webkit/browser/fileapi/file_permission_policy.h"
     17 #include "webkit/browser/fileapi/file_stream_writer.h"
     18 #include "webkit/browser/fileapi/file_system_file_util.h"
     19 #include "webkit/browser/fileapi/file_system_operation.h"
     20 #include "webkit/browser/fileapi/file_system_operation_runner.h"
     21 #include "webkit/browser/fileapi/file_system_options.h"
     22 #include "webkit/browser/fileapi/file_system_quota_client.h"
     23 #include "webkit/browser/fileapi/file_system_url.h"
     24 #include "webkit/browser/fileapi/isolated_context.h"
     25 #include "webkit/browser/fileapi/isolated_file_system_backend.h"
     26 #include "webkit/browser/fileapi/mount_points.h"
     27 #include "webkit/browser/fileapi/quota/quota_reservation.h"
     28 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
     29 #include "webkit/browser/quota/quota_manager_proxy.h"
     30 #include "webkit/browser/quota/special_storage_policy.h"
     31 #include "webkit/common/fileapi/file_system_info.h"
     32 #include "webkit/common/fileapi/file_system_util.h"
     33 
     34 using quota::QuotaClient;
     35 
     36 namespace fileapi {
     37 
     38 namespace {
     39 
     40 QuotaClient* CreateQuotaClient(
     41     FileSystemContext* context,
     42     bool is_incognito) {
     43   return new FileSystemQuotaClient(context, is_incognito);
     44 }
     45 
     46 
     47 void DidGetMetadataForResolveURL(
     48     const base::FilePath& path,
     49     const FileSystemContext::ResolveURLCallback& callback,
     50     const FileSystemInfo& info,
     51     base::File::Error error,
     52     const base::File::Info& file_info) {
     53   if (error != base::File::FILE_OK) {
     54     if (error == base::File::FILE_ERROR_NOT_FOUND) {
     55       callback.Run(base::File::FILE_OK, info, path,
     56                    FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
     57     } else {
     58       callback.Run(error, FileSystemInfo(), base::FilePath(),
     59                    FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
     60     }
     61     return;
     62   }
     63   callback.Run(error, info, path, file_info.is_directory ?
     64       FileSystemContext::RESOLVED_ENTRY_DIRECTORY :
     65       FileSystemContext::RESOLVED_ENTRY_FILE);
     66 }
     67 
     68 void RelayResolveURLCallback(
     69     scoped_refptr<base::MessageLoopProxy> message_loop,
     70     const FileSystemContext::ResolveURLCallback& callback,
     71     base::File::Error result,
     72     const FileSystemInfo& info,
     73     const base::FilePath& file_path,
     74     FileSystemContext::ResolvedEntryType type) {
     75   message_loop->PostTask(
     76       FROM_HERE, base::Bind(callback, result, info, file_path, type));
     77 }
     78 
     79 }  // namespace
     80 
     81 // static
     82 int FileSystemContext::GetPermissionPolicy(FileSystemType type) {
     83   switch (type) {
     84     case kFileSystemTypeTemporary:
     85     case kFileSystemTypePersistent:
     86     case kFileSystemTypeSyncable:
     87       return FILE_PERMISSION_SANDBOX;
     88 
     89     case kFileSystemTypeDrive:
     90     case kFileSystemTypeNativeForPlatformApp:
     91     case kFileSystemTypeNativeLocal:
     92     case kFileSystemTypeCloudDevice:
     93     case kFileSystemTypeProvided:
     94     case kFileSystemTypeDeviceMediaAsFileStorage:
     95       return FILE_PERMISSION_USE_FILE_PERMISSION;
     96 
     97     case kFileSystemTypeRestrictedNativeLocal:
     98       return FILE_PERMISSION_READ_ONLY |
     99              FILE_PERMISSION_USE_FILE_PERMISSION;
    100 
    101     case kFileSystemTypeDeviceMedia:
    102     case kFileSystemTypeIphoto:
    103     case kFileSystemTypeItunes:
    104     case kFileSystemTypeNativeMedia:
    105     case kFileSystemTypePicasa:
    106       return FILE_PERMISSION_USE_FILE_PERMISSION;
    107 
    108     // Following types are only accessed via IsolatedFileSystem, and
    109     // don't have their own permission policies.
    110     case kFileSystemTypeDragged:
    111     case kFileSystemTypeForTransientFile:
    112     case kFileSystemTypePluginPrivate:
    113       return FILE_PERMISSION_ALWAYS_DENY;
    114 
    115     // Following types only appear as mount_type, and will not be
    116     // queried for their permission policies.
    117     case kFileSystemTypeIsolated:
    118     case kFileSystemTypeExternal:
    119       return FILE_PERMISSION_ALWAYS_DENY;
    120 
    121     // Following types should not be used to access files by FileAPI clients.
    122     case kFileSystemTypeTest:
    123     case kFileSystemTypeSyncableForInternalSync:
    124     case kFileSystemInternalTypeEnumEnd:
    125     case kFileSystemInternalTypeEnumStart:
    126     case kFileSystemTypeUnknown:
    127       return FILE_PERMISSION_ALWAYS_DENY;
    128   }
    129   NOTREACHED();
    130   return FILE_PERMISSION_ALWAYS_DENY;
    131 }
    132 
    133 FileSystemContext::FileSystemContext(
    134     base::SingleThreadTaskRunner* io_task_runner,
    135     base::SequencedTaskRunner* file_task_runner,
    136     ExternalMountPoints* external_mount_points,
    137     quota::SpecialStoragePolicy* special_storage_policy,
    138     quota::QuotaManagerProxy* quota_manager_proxy,
    139     ScopedVector<FileSystemBackend> additional_backends,
    140     const std::vector<URLRequestAutoMountHandler>& auto_mount_handlers,
    141     const base::FilePath& partition_path,
    142     const FileSystemOptions& options)
    143     : io_task_runner_(io_task_runner),
    144       default_file_task_runner_(file_task_runner),
    145       quota_manager_proxy_(quota_manager_proxy),
    146       sandbox_delegate_(new SandboxFileSystemBackendDelegate(
    147           quota_manager_proxy,
    148           file_task_runner,
    149           partition_path,
    150           special_storage_policy,
    151           options)),
    152       sandbox_backend_(new SandboxFileSystemBackend(
    153           sandbox_delegate_.get())),
    154       isolated_backend_(new IsolatedFileSystemBackend()),
    155       plugin_private_backend_(new PluginPrivateFileSystemBackend(
    156           file_task_runner,
    157           partition_path,
    158           special_storage_policy,
    159           options)),
    160       additional_backends_(additional_backends.Pass()),
    161       auto_mount_handlers_(auto_mount_handlers),
    162       external_mount_points_(external_mount_points),
    163       partition_path_(partition_path),
    164       is_incognito_(options.is_incognito()),
    165       operation_runner_(new FileSystemOperationRunner(this)) {
    166   RegisterBackend(sandbox_backend_.get());
    167   RegisterBackend(isolated_backend_.get());
    168   RegisterBackend(plugin_private_backend_.get());
    169 
    170   for (ScopedVector<FileSystemBackend>::const_iterator iter =
    171           additional_backends_.begin();
    172        iter != additional_backends_.end(); ++iter) {
    173     RegisterBackend(*iter);
    174   }
    175 
    176   if (quota_manager_proxy) {
    177     // Quota client assumes all backends have registered.
    178     quota_manager_proxy->RegisterClient(CreateQuotaClient(
    179             this, options.is_incognito()));
    180   }
    181 
    182   sandbox_backend_->Initialize(this);
    183   isolated_backend_->Initialize(this);
    184   plugin_private_backend_->Initialize(this);
    185   for (ScopedVector<FileSystemBackend>::const_iterator iter =
    186           additional_backends_.begin();
    187        iter != additional_backends_.end(); ++iter) {
    188     (*iter)->Initialize(this);
    189   }
    190 
    191   // Additional mount points must be added before regular system-wide
    192   // mount points.
    193   if (external_mount_points)
    194     url_crackers_.push_back(external_mount_points);
    195   url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
    196   url_crackers_.push_back(IsolatedContext::GetInstance());
    197 }
    198 
    199 bool FileSystemContext::DeleteDataForOriginOnFileTaskRunner(
    200     const GURL& origin_url) {
    201   DCHECK(default_file_task_runner()->RunsTasksOnCurrentThread());
    202   DCHECK(origin_url == origin_url.GetOrigin());
    203 
    204   bool success = true;
    205   for (FileSystemBackendMap::iterator iter = backend_map_.begin();
    206        iter != backend_map_.end();
    207        ++iter) {
    208     FileSystemBackend* backend = iter->second;
    209     if (!backend->GetQuotaUtil())
    210       continue;
    211     if (backend->GetQuotaUtil()->DeleteOriginDataOnFileTaskRunner(
    212             this, quota_manager_proxy(), origin_url, iter->first)
    213             != base::File::FILE_OK) {
    214       // Continue the loop, but record the failure.
    215       success = false;
    216     }
    217   }
    218 
    219   return success;
    220 }
    221 
    222 scoped_refptr<QuotaReservation>
    223 FileSystemContext::CreateQuotaReservationOnFileTaskRunner(
    224     const GURL& origin_url,
    225     FileSystemType type) {
    226   DCHECK(default_file_task_runner()->RunsTasksOnCurrentThread());
    227   FileSystemBackend* backend = GetFileSystemBackend(type);
    228   if (!backend || !backend->GetQuotaUtil())
    229     return scoped_refptr<QuotaReservation>();
    230   return backend->GetQuotaUtil()->CreateQuotaReservationOnFileTaskRunner(
    231       origin_url, type);
    232 }
    233 
    234 void FileSystemContext::Shutdown() {
    235   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
    236     io_task_runner_->PostTask(
    237         FROM_HERE, base::Bind(&FileSystemContext::Shutdown,
    238                               make_scoped_refptr(this)));
    239     return;
    240   }
    241   operation_runner_->Shutdown();
    242 }
    243 
    244 FileSystemQuotaUtil*
    245 FileSystemContext::GetQuotaUtil(FileSystemType type) const {
    246   FileSystemBackend* backend = GetFileSystemBackend(type);
    247   if (!backend)
    248     return NULL;
    249   return backend->GetQuotaUtil();
    250 }
    251 
    252 AsyncFileUtil* FileSystemContext::GetAsyncFileUtil(
    253     FileSystemType type) const {
    254   FileSystemBackend* backend = GetFileSystemBackend(type);
    255   if (!backend)
    256     return NULL;
    257   return backend->GetAsyncFileUtil(type);
    258 }
    259 
    260 CopyOrMoveFileValidatorFactory*
    261 FileSystemContext::GetCopyOrMoveFileValidatorFactory(
    262     FileSystemType type, base::File::Error* error_code) const {
    263   DCHECK(error_code);
    264   *error_code = base::File::FILE_OK;
    265   FileSystemBackend* backend = GetFileSystemBackend(type);
    266   if (!backend)
    267     return NULL;
    268   return backend->GetCopyOrMoveFileValidatorFactory(
    269       type, error_code);
    270 }
    271 
    272 FileSystemBackend* FileSystemContext::GetFileSystemBackend(
    273     FileSystemType type) const {
    274   FileSystemBackendMap::const_iterator found = backend_map_.find(type);
    275   if (found != backend_map_.end())
    276     return found->second;
    277   NOTREACHED() << "Unknown filesystem type: " << type;
    278   return NULL;
    279 }
    280 
    281 bool FileSystemContext::IsSandboxFileSystem(FileSystemType type) const {
    282   FileSystemBackendMap::const_iterator found = backend_map_.find(type);
    283   return found != backend_map_.end() && found->second->GetQuotaUtil();
    284 }
    285 
    286 const UpdateObserverList* FileSystemContext::GetUpdateObservers(
    287     FileSystemType type) const {
    288   FileSystemBackend* backend = GetFileSystemBackend(type);
    289   if (backend->GetQuotaUtil())
    290     return backend->GetQuotaUtil()->GetUpdateObservers(type);
    291   return NULL;
    292 }
    293 
    294 const AccessObserverList* FileSystemContext::GetAccessObservers(
    295     FileSystemType type) const {
    296   FileSystemBackend* backend = GetFileSystemBackend(type);
    297   if (backend->GetQuotaUtil())
    298     return backend->GetQuotaUtil()->GetAccessObservers(type);
    299   return NULL;
    300 }
    301 
    302 void FileSystemContext::GetFileSystemTypes(
    303     std::vector<FileSystemType>* types) const {
    304   types->clear();
    305   for (FileSystemBackendMap::const_iterator iter = backend_map_.begin();
    306        iter != backend_map_.end(); ++iter)
    307     types->push_back(iter->first);
    308 }
    309 
    310 ExternalFileSystemBackend*
    311 FileSystemContext::external_backend() const {
    312   return static_cast<ExternalFileSystemBackend*>(
    313       GetFileSystemBackend(kFileSystemTypeExternal));
    314 }
    315 
    316 void FileSystemContext::OpenFileSystem(
    317     const GURL& origin_url,
    318     FileSystemType type,
    319     OpenFileSystemMode mode,
    320     const OpenFileSystemCallback& callback) {
    321   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
    322   DCHECK(!callback.is_null());
    323 
    324   if (!FileSystemContext::IsSandboxFileSystem(type)) {
    325     // Disallow opening a non-sandboxed filesystem.
    326     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
    327     return;
    328   }
    329 
    330   FileSystemBackend* backend = GetFileSystemBackend(type);
    331   if (!backend) {
    332     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
    333     return;
    334   }
    335 
    336   backend->ResolveURL(
    337       CreateCrackedFileSystemURL(origin_url, type, base::FilePath()),
    338       mode,
    339       callback);
    340 }
    341 
    342 void FileSystemContext::ResolveURL(
    343     const FileSystemURL& url,
    344     const ResolveURLCallback& callback) {
    345   DCHECK(!callback.is_null());
    346 
    347   // If not on IO thread, forward before passing the task to the backend.
    348   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
    349     ResolveURLCallback relay_callback =
    350         base::Bind(&RelayResolveURLCallback,
    351                    base::MessageLoopProxy::current(), callback);
    352     io_task_runner_->PostTask(
    353         FROM_HERE,
    354         base::Bind(&FileSystemContext::ResolveURL, this, url, relay_callback));
    355     return;
    356   }
    357 
    358   FileSystemBackend* backend = GetFileSystemBackend(url.type());
    359   if (!backend) {
    360     callback.Run(base::File::FILE_ERROR_SECURITY,
    361                  FileSystemInfo(), base::FilePath(),
    362                  FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
    363     return;
    364   }
    365 
    366   backend->ResolveURL(
    367       url,
    368       OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
    369       base::Bind(&FileSystemContext::DidOpenFileSystemForResolveURL,
    370                  this,
    371                  url,
    372                  callback));
    373 }
    374 
    375 void FileSystemContext::AttemptAutoMountForURLRequest(
    376     const net::URLRequest* url_request,
    377     const std::string& storage_domain,
    378     const StatusCallback& callback) {
    379   FileSystemURL filesystem_url(url_request->url());
    380   if (filesystem_url.type() == kFileSystemTypeExternal) {
    381     for (size_t i = 0; i < auto_mount_handlers_.size(); i++) {
    382       if (auto_mount_handlers_[i].Run(url_request, filesystem_url,
    383                                       storage_domain, callback)) {
    384         return;
    385       }
    386     }
    387   }
    388   callback.Run(base::File::FILE_ERROR_NOT_FOUND);
    389 }
    390 
    391 void FileSystemContext::DeleteFileSystem(
    392     const GURL& origin_url,
    393     FileSystemType type,
    394     const StatusCallback& callback) {
    395   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
    396   DCHECK(origin_url == origin_url.GetOrigin());
    397   DCHECK(!callback.is_null());
    398 
    399   FileSystemBackend* backend = GetFileSystemBackend(type);
    400   if (!backend) {
    401     callback.Run(base::File::FILE_ERROR_SECURITY);
    402     return;
    403   }
    404   if (!backend->GetQuotaUtil()) {
    405     callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
    406     return;
    407   }
    408 
    409   base::PostTaskAndReplyWithResult(
    410       default_file_task_runner(),
    411       FROM_HERE,
    412       // It is safe to pass Unretained(quota_util) since context owns it.
    413       base::Bind(&FileSystemQuotaUtil::DeleteOriginDataOnFileTaskRunner,
    414                  base::Unretained(backend->GetQuotaUtil()),
    415                  make_scoped_refptr(this),
    416                  base::Unretained(quota_manager_proxy()),
    417                  origin_url,
    418                  type),
    419       callback);
    420 }
    421 
    422 scoped_ptr<webkit_blob::FileStreamReader>
    423 FileSystemContext::CreateFileStreamReader(
    424     const FileSystemURL& url,
    425     int64 offset,
    426     const base::Time& expected_modification_time) {
    427   if (!url.is_valid())
    428     return scoped_ptr<webkit_blob::FileStreamReader>();
    429   FileSystemBackend* backend = GetFileSystemBackend(url.type());
    430   if (!backend)
    431     return scoped_ptr<webkit_blob::FileStreamReader>();
    432   return backend->CreateFileStreamReader(
    433       url, offset, expected_modification_time, this);
    434 }
    435 
    436 scoped_ptr<FileStreamWriter> FileSystemContext::CreateFileStreamWriter(
    437     const FileSystemURL& url,
    438     int64 offset) {
    439   if (!url.is_valid())
    440     return scoped_ptr<FileStreamWriter>();
    441   FileSystemBackend* backend = GetFileSystemBackend(url.type());
    442   if (!backend)
    443     return scoped_ptr<FileStreamWriter>();
    444   return backend->CreateFileStreamWriter(url, offset, this);
    445 }
    446 
    447 scoped_ptr<FileSystemOperationRunner>
    448 FileSystemContext::CreateFileSystemOperationRunner() {
    449   return make_scoped_ptr(new FileSystemOperationRunner(this));
    450 }
    451 
    452 FileSystemURL FileSystemContext::CrackURL(const GURL& url) const {
    453   return CrackFileSystemURL(FileSystemURL(url));
    454 }
    455 
    456 FileSystemURL FileSystemContext::CreateCrackedFileSystemURL(
    457     const GURL& origin,
    458     FileSystemType type,
    459     const base::FilePath& path) const {
    460   return CrackFileSystemURL(FileSystemURL(origin, type, path));
    461 }
    462 
    463 #if defined(OS_CHROMEOS)
    464 void FileSystemContext::EnableTemporaryFileSystemInIncognito() {
    465   sandbox_backend_->set_enable_temporary_file_system_in_incognito(true);
    466 }
    467 #endif
    468 
    469 bool FileSystemContext::CanServeURLRequest(const FileSystemURL& url) const {
    470   // We never support accessing files in isolated filesystems via an URL.
    471   if (url.mount_type() == kFileSystemTypeIsolated)
    472     return false;
    473 #if defined(OS_CHROMEOS)
    474   if (url.type() == kFileSystemTypeTemporary &&
    475       sandbox_backend_->enable_temporary_file_system_in_incognito()) {
    476     return true;
    477   }
    478 #endif
    479   return !is_incognito_ || !FileSystemContext::IsSandboxFileSystem(url.type());
    480 }
    481 
    482 bool FileSystemContext::ShouldFlushOnWriteCompletion(
    483     FileSystemType type) const {
    484   if (IsSandboxFileSystem(type)) {
    485     // Disable Flush() for each write operation on SandboxFileSystems since it
    486     // hurts the performance, assuming the FileSystems are stored in a local
    487     // disk, we don't need to keep calling fsync() for it.
    488     // On the other hand, other FileSystems that may stored on a removable media
    489     // should be Flush()ed as soon as a write operation is completed, so that
    490     // written data is saved over sudden media removal.
    491     return false;
    492   }
    493   return true;
    494 }
    495 
    496 void FileSystemContext::OpenPluginPrivateFileSystem(
    497     const GURL& origin_url,
    498     FileSystemType type,
    499     const std::string& filesystem_id,
    500     const std::string& plugin_id,
    501     OpenFileSystemMode mode,
    502     const StatusCallback& callback) {
    503   DCHECK(plugin_private_backend_);
    504   plugin_private_backend_->OpenPrivateFileSystem(
    505       origin_url, type, filesystem_id, plugin_id, mode, callback);
    506 }
    507 
    508 FileSystemContext::~FileSystemContext() {
    509 }
    510 
    511 void FileSystemContext::DeleteOnCorrectThread() const {
    512   if (!io_task_runner_->RunsTasksOnCurrentThread() &&
    513       io_task_runner_->DeleteSoon(FROM_HERE, this)) {
    514     return;
    515   }
    516   delete this;
    517 }
    518 
    519 FileSystemOperation* FileSystemContext::CreateFileSystemOperation(
    520     const FileSystemURL& url, base::File::Error* error_code) {
    521   if (!url.is_valid()) {
    522     if (error_code)
    523       *error_code = base::File::FILE_ERROR_INVALID_URL;
    524     return NULL;
    525   }
    526 
    527   FileSystemBackend* backend = GetFileSystemBackend(url.type());
    528   if (!backend) {
    529     if (error_code)
    530       *error_code = base::File::FILE_ERROR_FAILED;
    531     return NULL;
    532   }
    533 
    534   base::File::Error fs_error = base::File::FILE_OK;
    535   FileSystemOperation* operation =
    536       backend->CreateFileSystemOperation(url, this, &fs_error);
    537 
    538   if (error_code)
    539     *error_code = fs_error;
    540   return operation;
    541 }
    542 
    543 FileSystemURL FileSystemContext::CrackFileSystemURL(
    544     const FileSystemURL& url) const {
    545   if (!url.is_valid())
    546     return FileSystemURL();
    547 
    548   // The returned value in case there is no crackers which can crack the url.
    549   // This is valid situation for non isolated/external file systems.
    550   FileSystemURL current = url;
    551 
    552   // File system may be mounted multiple times (e.g., an isolated filesystem on
    553   // top of an external filesystem). Hence cracking needs to be iterated.
    554   for (;;) {
    555     FileSystemURL cracked = current;
    556     for (size_t i = 0; i < url_crackers_.size(); ++i) {
    557       if (!url_crackers_[i]->HandlesFileSystemMountType(current.type()))
    558         continue;
    559       cracked = url_crackers_[i]->CrackFileSystemURL(current);
    560       if (cracked.is_valid())
    561         break;
    562     }
    563     if (cracked == current)
    564       break;
    565     current = cracked;
    566   }
    567   return current;
    568 }
    569 
    570 void FileSystemContext::RegisterBackend(FileSystemBackend* backend) {
    571   const FileSystemType mount_types[] = {
    572     kFileSystemTypeTemporary,
    573     kFileSystemTypePersistent,
    574     kFileSystemTypeIsolated,
    575     kFileSystemTypeExternal,
    576   };
    577   // Register file system backends for public mount types.
    578   for (size_t j = 0; j < ARRAYSIZE_UNSAFE(mount_types); ++j) {
    579     if (backend->CanHandleType(mount_types[j])) {
    580       const bool inserted = backend_map_.insert(
    581           std::make_pair(mount_types[j], backend)).second;
    582       DCHECK(inserted);
    583     }
    584   }
    585   // Register file system backends for internal types.
    586   for (int t = kFileSystemInternalTypeEnumStart + 1;
    587        t < kFileSystemInternalTypeEnumEnd; ++t) {
    588     FileSystemType type = static_cast<FileSystemType>(t);
    589     if (backend->CanHandleType(type)) {
    590       const bool inserted = backend_map_.insert(
    591           std::make_pair(type, backend)).second;
    592       DCHECK(inserted);
    593     }
    594   }
    595 }
    596 
    597 void FileSystemContext::DidOpenFileSystemForResolveURL(
    598     const FileSystemURL& url,
    599     const FileSystemContext::ResolveURLCallback& callback,
    600     const GURL& filesystem_root,
    601     const std::string& filesystem_name,
    602     base::File::Error error) {
    603   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
    604 
    605   if (error != base::File::FILE_OK) {
    606     callback.Run(error, FileSystemInfo(), base::FilePath(),
    607                  FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
    608     return;
    609   }
    610 
    611   fileapi::FileSystemInfo info(
    612       filesystem_name, filesystem_root, url.mount_type());
    613 
    614   // Extract the virtual path not containing a filesystem type part from |url|.
    615   base::FilePath parent = CrackURL(filesystem_root).virtual_path();
    616   base::FilePath child = url.virtual_path();
    617   base::FilePath path;
    618 
    619   if (parent.empty()) {
    620     path = child;
    621   } else if (parent != child) {
    622     bool result = parent.AppendRelativePath(child, &path);
    623     DCHECK(result);
    624   }
    625 
    626   operation_runner()->GetMetadata(
    627       url, base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
    628 }
    629 
    630 }  // namespace fileapi
    631