New FileSystemURL cracking

webkit/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/fileapi/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/single_thread_task_runner.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_quota_client.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_mount_point_provider.h"
+#include "webkit/fileapi/mount_points.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/local_file_sync_context.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/fileapi/test_mount_point_provider.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 #if defined(OS_CHROMEOS)
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
@@ skipping 37 matching lines @@
               options)),
       isolated_provider_(new IsolatedMountPointProvider(partition_path)),
       partition_path_(partition_path) {
   DCHECK(task_runners_.get());
 
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(CreateQuotaClient(
             this, options.is_incognito()));
   }
 #if defined(OS_CHROMEOS)
+  // TODO(tbarzic): Pass this through ctor.
+  scoped_refptr<ExternalMountPoints> external_mount_points =
+      ExternalMountPoints::CreateRefCounted();
+  // |external_provider_| will take a reference or external_mount_points so this
+  // doesn't have to retain one for itself.
   external_provider_.reset(
       new chromeos::CrosMountPointProvider(
           special_storage_policy,
-          // TODO(tbarzic): Switch this to |external_mount_points_|.
-          fileapi::ExternalMountPoints::GetSystemInstance(),
-          fileapi::ExternalMountPoints::GetSystemInstance()));
+          external_mount_points,
+          ExternalMountPoints::GetSystemInstance()));
+  url_crackers_.push_back(external_mount_points.get());
 #endif
+
+  url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
+  url_crackers_.push_back(IsolatedContext::GetInstance());
 }
 
 bool FileSystemContext::DeleteDataForOriginOnFileThread(
     const GURL& origin_url) {
   DCHECK(task_runners_->file_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(sandbox_provider());
   DCHECK(origin_url == origin_url.GetOrigin());
 
   // Delete temporary and persistent data.
   return
@@ skipping 204 matching lines @@
   sandbox_provider_->AddSyncableFileChangeObserver(
       change_tracker_.get(),
       task_runners_->file_task_runner());
 }
 
 void FileSystemContext::set_sync_context(
     LocalFileSyncContext* sync_context) {
   sync_context_ = sync_context;
 }
 
+FileSystemURL FileSystemContext::CrackURL(const GURL& url) const {
+  return CrackFileSystemURL(FileSystemURL(url));
+}
+
+FileSystemURL FileSystemContext::CreateCrackedFileSystemURL(
+    const GURL& origin,
+    FileSystemType type,
+    const FilePath& path) const {
+  return CrackFileSystemURL(FileSystemURL(origin, type, path));
+}
+
 FileSystemContext::~FileSystemContext() {
   task_runners_->file_task_runner()->DeleteSoon(
       FROM_HERE, change_tracker_.release());
 }
 
 void FileSystemContext::DeleteOnCorrectThread() const {
   if (!task_runners_->io_task_runner()->RunsTasksOnCurrentThread() &&
       task_runners_->io_task_runner()->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   STLDeleteContainerPairSecondPointers(provider_map_.begin(),
                                        provider_map_.end());
   delete this;
 }
 
+FileSystemURL FileSystemContext::CrackFileSystemURL(
+    const FileSystemURL& url) const {
+  if (!url.is_valid())
+    return FileSystemURL();
+
+  // The returned value in case there is no crackers which can crack the url.
+  // This is valid situation for non isolated/external file systems.
+  FileSystemURL result = url;
+
+  for (size_t i = 0; i < url_crackers_.size(); ++i) {
+    if (!url_crackers_[i]->HandlesFileSystemMountType(url.type()))
+      continue;
+
+    result = url_crackers_[i]->CreateCrackedFileSystemURL(url.origin(),
+                                                          url.type(),
+                                                          url.path());
+    if (result.is_valid())
+      return result;
+  }
+
+  return result;
+}
+
 }  // namespace fileapi