FileAPI: Factor out getting root URI and FS name parts into each FS backend

webkit/browser/fileapi/sandbox_file_system_backend.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/sandbox_file_system_backend.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_stream_reader.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_options.h"
 #include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/file_system_usage_cache.h"
 #include "webkit/browser/fileapi/local_file_system_operation.h"
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/browser/fileapi/sandbox_quota_observer.h"
 #include "webkit/browser/fileapi/syncable/syncable_file_system_operation.h"
+#include "webkit/browser/fileapi/syncable/syncable_file_system_util.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using quota::QuotaManagerProxy;
 
 namespace fileapi {
 
 namespace {
 
@@ skipping 49 matching lines @@
   virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
     return enum_->HasFileSystemType(type);
   }
 
  private:
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
 void DidOpenFileSystem(
     base::WeakPtr<SandboxFileSystemBackend> mount_point_provider,
-    const FileSystemBackend::OpenFileSystemCallback& callback,
+    const base::Callback<void(base::PlatformFileError error)>& callback,
     base::PlatformFileError* error) {
   if (mount_point_provider.get())
     mount_point_provider.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
 void OpenFileSystemOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
@@ skipping 90 matching lines @@
 }
 
 bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent ||
          type == kFileSystemTypeSyncable ||
          type == kFileSystemTypeSyncableForInternalSync;
 }
 
 void SandboxFileSystemBackend::OpenFileSystem(
-    const GURL& origin_url, fileapi::FileSystemType type,
+    const GURL& origin_url,
+    fileapi::FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   if (file_system_options_.is_incognito() &&
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kInvalidSchemeError,
                               kFileSystemErrorMax);
     return;
   }
 
+  // TODO(nhiroki): Factor out SyncFS related code to SyncFileSystemBackend we
+  // plan to introduce. (http://crbug.com/242422/)
+  GURL root_url = (type == kFileSystemTypeSyncable)
+      ? sync_file_system::GetSyncableFileSystemRootURI(origin_url)
+      : GetFileSystemRootURI(origin_url, type);
+  std::string name = GetFileSystemName(origin_url, type);
+
   base::PlatformFileError* error_ptr = new base::PlatformFileError;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&OpenFileSystemOnFileThread,
                  sandbox_sync_file_util(),
                  origin_url, type, mode,
                  base::Unretained(error_ptr)),
       base::Bind(&DidOpenFileSystem,
                  weak_factory_.GetWeakPtr(),
-                 callback, base::Owned(error_ptr)));
+                 base::Bind(callback, root_url, name),
+                 base::Owned(error_ptr)));
 
   if (enable_usage_tracking_)
     return;
 
   // Schedule full usage recalculation on the next launch without
   // --disable-file-system-usage-tracking.
   file_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SandboxFileSystemBackend::InvalidateUsageCacheOnFileThread,
                  sandbox_sync_file_util(), origin_url, type,
@@ skipping 415 matching lines @@
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
 
   return usage;
 }
 
 }  // namespace fileapi