FileAPI: Move OpenFileSystem into SandboxContext

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/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 17 matching lines @@
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using quota::QuotaManagerProxy;
 using quota::SpecialStoragePolicy;
 
 namespace fileapi {
 
 namespace {
 
-const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
-const char kOpenFileSystemDetailLabel[] = "FileSystem.OpenFileSystemDetail";
-const char kOpenFileSystemDetailNonThrottledLabel[] =
-    "FileSystem.OpenFileSystemDetailNonthrottled";
-int64 kMinimumStatsCollectionIntervalHours = 1;
-
-enum FileSystemError {
-  kOK = 0,
-  kIncognito,
-  kInvalidSchemeError,
-  kCreateDirectoryError,
-  kNotFound,
-  kUnknownError,
-  kFileSystemErrorMax,
-};
-
 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
 
-void DidOpenFileSystem(
-    base::WeakPtr<SandboxFileSystemBackend> sandbox_backend,
-    const base::Callback<void(base::PlatformFileError error)>& callback,
-    base::PlatformFileError* error) {
-  if (sandbox_backend.get())
-    sandbox_backend.get()->CollectOpenFileSystemMetrics(*error);
-  callback.Run(*error);
-}
-
-void OpenFileSystemOnFileThread(
-    ObfuscatedFileUtil* file_util,
-    const GURL& origin_url,
-    FileSystemType type,
-    OpenFileSystemMode mode,
-    base::PlatformFileError* error_ptr) {
-  DCHECK(error_ptr);
-  const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
-  file_util->GetDirectoryForOriginAndType(origin_url, type, create, error_ptr);
-  if (*error_ptr != base::PLATFORM_FILE_OK) {
-    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
-                              kCreateDirectoryError,
-                              kFileSystemErrorMax);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
-  }
-  // The reference of file_util will be derefed on the FILE thread
-  // when the storage of this callback gets deleted regardless of whether
-  // this method is called or not.
-}
-
 }  // anonymous namespace
 
 SandboxFileSystemBackend::SandboxFileSystemBackend(
     SandboxContext* sandbox_context)
     : sandbox_context_(sandbox_context),
-      enable_temporary_file_system_in_incognito_(false),
-      weak_factory_(this) {
+      enable_temporary_file_system_in_incognito_(false) {
 }
 
 SandboxFileSystemBackend::~SandboxFileSystemBackend() {
 }
 
 bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent ||
          type == kFileSystemTypeSyncable ||
          type == kFileSystemTypeSyncableForInternalSync;
@@ skipping 27 matching lines @@
   DCHECK(CanHandleType(type));
   DCHECK(sandbox_context_);
   if (sandbox_context_->file_system_options().is_incognito() &&
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
     return;
   }
 
-  if (!sandbox_context_->IsAllowedScheme(origin_url)) {
-    callback.Run(GURL(), std::string(), base::PLATFORM_FILE_ERROR_SECURITY);
-    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;
-  sandbox_context_->file_task_runner()->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&OpenFileSystemOnFileThread,
-                 sandbox_context_->sync_file_util(),
-                 origin_url, type, mode,
-                 base::Unretained(error_ptr)),
-      base::Bind(&DidOpenFileSystem,
-                 weak_factory_.GetWeakPtr(),
-                 base::Bind(callback, root_url, name),
-                 base::Owned(error_ptr)));
-};
+  sandbox_context_->OpenFileSystem(
+      origin_url, type, mode, callback, root_url);
+}
 
 FileSystemFileUtil* SandboxFileSystemBackend::GetFileUtil(
     FileSystemType type) {
-  DCHECK(sandbox_context_);
   return sandbox_context_->sync_file_util();
 }
 
 AsyncFileUtil* SandboxFileSystemBackend::GetAsyncFileUtil(
     FileSystemType type) {
   DCHECK(sandbox_context_);
   return sandbox_context_->file_util();
 }
 
 CopyOrMoveFileValidatorFactory*
@@ skipping 186 matching lines @@
     return &syncable_change_observers_;
   return &change_observers_;
 }
 
 const AccessObserverList* SandboxFileSystemBackend::GetAccessObservers(
     FileSystemType type) const {
   DCHECK(CanHandleType(type));
   return &access_observers_;
 }
 
-void SandboxFileSystemBackend::CollectOpenFileSystemMetrics(
-    base::PlatformFileError error_code) {
-  base::Time now = base::Time::Now();
-  bool throttled = now < next_release_time_for_open_filesystem_stat_;
-  if (!throttled) {
-    next_release_time_for_open_filesystem_stat_ =
-        now + base::TimeDelta::FromHours(kMinimumStatsCollectionIntervalHours);
-  }
-
-#define REPORT(report_value)                                            \
-  UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailLabel,                 \
-                            (report_value),                             \
-                            kFileSystemErrorMax);                       \
-  if (!throttled) {                                                     \
-    UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailNonThrottledLabel,   \
-                              (report_value),                           \
-                              kFileSystemErrorMax);                     \
-  }
-
-  switch (error_code) {
-    case base::PLATFORM_FILE_OK:
-      REPORT(kOK);
-      break;
-    case base::PLATFORM_FILE_ERROR_INVALID_URL:
-      REPORT(kInvalidSchemeError);
-      break;
-    case base::PLATFORM_FILE_ERROR_NOT_FOUND:
-      REPORT(kNotFound);
-      break;
-    case base::PLATFORM_FILE_ERROR_FAILED:
-    default:
-      REPORT(kUnknownError);
-      break;
-  }
-#undef REPORT
-}
-
 }  // namespace fileapi