sandbox_file_system_backend.cc 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  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. #include "storage/browser/file_system/sandbox_file_system_backend.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/check.h"
  10. #include "base/files/file_util.h"
  11. #include "base/metrics/histogram.h"
  12. #include "base/task/task_runner_util.h"
  13. #include "storage/browser/file_system/async_file_util_adapter.h"
  14. #include "storage/browser/file_system/copy_or_move_file_validator.h"
  15. #include "storage/browser/file_system/file_stream_reader.h"
  16. #include "storage/browser/file_system/file_stream_writer.h"
  17. #include "storage/browser/file_system/file_system_context.h"
  18. #include "storage/browser/file_system/file_system_features.h"
  19. #include "storage/browser/file_system/file_system_operation.h"
  20. #include "storage/browser/file_system/file_system_operation_context.h"
  21. #include "storage/browser/file_system/file_system_options.h"
  22. #include "storage/browser/file_system/file_system_usage_cache.h"
  23. #include "storage/browser/file_system/obfuscated_file_util.h"
  24. #include "storage/browser/file_system/quota/quota_limit_type.h"
  25. #include "storage/browser/file_system/sandbox_quota_observer.h"
  26. #include "storage/browser/quota/quota_manager.h"
  27. #include "storage/common/file_system/file_system_types.h"
  28. #include "storage/common/file_system/file_system_util.h"
  29. #include "url/gurl.h"
  30. namespace storage {
  31. SandboxFileSystemBackend::SandboxFileSystemBackend(
  32. SandboxFileSystemBackendDelegate* delegate)
  33. : delegate_(delegate) {}
  34. SandboxFileSystemBackend::~SandboxFileSystemBackend() = default;
  35. bool SandboxFileSystemBackend::CanHandleType(FileSystemType type) const {
  36. return type == kFileSystemTypeTemporary || type == kFileSystemTypePersistent;
  37. }
  38. void SandboxFileSystemBackend::Initialize(FileSystemContext* context) {
  39. DCHECK(delegate_);
  40. // Set quota observers.
  41. delegate_->RegisterQuotaUpdateObserver(kFileSystemTypeTemporary);
  42. delegate_->AddFileAccessObserver(kFileSystemTypeTemporary,
  43. delegate_->quota_observer(), nullptr);
  44. delegate_->RegisterQuotaUpdateObserver(kFileSystemTypePersistent);
  45. delegate_->AddFileAccessObserver(kFileSystemTypePersistent,
  46. delegate_->quota_observer(), nullptr);
  47. }
  48. void SandboxFileSystemBackend::ResolveURL(const FileSystemURL& url,
  49. OpenFileSystemMode mode,
  50. ResolveURLCallback callback) {
  51. DCHECK(CanHandleType(url.type()));
  52. DCHECK(delegate_);
  53. if (delegate_->file_system_options().is_incognito() &&
  54. url.type() != kFileSystemTypeTemporary &&
  55. !base::FeatureList::IsEnabled(
  56. features::kEnablePersistentFilesystemInIncognito)) {
  57. // TODO(kinuko): return an isolated temporary directory.
  58. std::move(callback).Run(GURL(), std::string(),
  59. base::File::FILE_ERROR_SECURITY);
  60. return;
  61. }
  62. delegate_->OpenFileSystem(
  63. url.storage_key(), url.bucket(), url.type(), mode, std::move(callback),
  64. GetFileSystemRootURI(url.origin().GetURL(), url.type()));
  65. }
  66. AsyncFileUtil* SandboxFileSystemBackend::GetAsyncFileUtil(FileSystemType type) {
  67. DCHECK(delegate_);
  68. return delegate_->file_util();
  69. }
  70. WatcherManager* SandboxFileSystemBackend::GetWatcherManager(
  71. FileSystemType type) {
  72. return nullptr;
  73. }
  74. CopyOrMoveFileValidatorFactory*
  75. SandboxFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
  76. FileSystemType type,
  77. base::File::Error* error_code) {
  78. DCHECK(error_code);
  79. *error_code = base::File::FILE_OK;
  80. return nullptr;
  81. }
  82. std::unique_ptr<FileSystemOperation>
  83. SandboxFileSystemBackend::CreateFileSystemOperation(
  84. const FileSystemURL& url,
  85. FileSystemContext* context,
  86. base::File::Error* error_code) const {
  87. DCHECK(CanHandleType(url.type()));
  88. DCHECK(error_code);
  89. DCHECK(delegate_);
  90. std::unique_ptr<FileSystemOperationContext> operation_context =
  91. delegate_->CreateFileSystemOperationContext(url, context, error_code);
  92. if (!operation_context)
  93. return nullptr;
  94. SpecialStoragePolicy* policy = delegate_->special_storage_policy();
  95. if (policy && policy->IsStorageUnlimited(url.origin().GetURL()))
  96. operation_context->set_quota_limit_type(QuotaLimitType::kUnlimited);
  97. else
  98. operation_context->set_quota_limit_type(QuotaLimitType::kLimited);
  99. return FileSystemOperation::Create(url, context,
  100. std::move(operation_context));
  101. }
  102. bool SandboxFileSystemBackend::SupportsStreaming(
  103. const FileSystemURL& url) const {
  104. // Streaming is required for in-memory implementation to access memory-backed
  105. // files.
  106. return delegate_->file_system_options().is_incognito();
  107. }
  108. bool SandboxFileSystemBackend::HasInplaceCopyImplementation(
  109. FileSystemType type) const {
  110. return false;
  111. }
  112. std::unique_ptr<FileStreamReader>
  113. SandboxFileSystemBackend::CreateFileStreamReader(
  114. const FileSystemURL& url,
  115. int64_t offset,
  116. int64_t max_bytes_to_read,
  117. const base::Time& expected_modification_time,
  118. FileSystemContext* context) const {
  119. DCHECK(CanHandleType(url.type()));
  120. DCHECK(delegate_);
  121. return delegate_->CreateFileStreamReader(url, offset,
  122. expected_modification_time, context);
  123. }
  124. std::unique_ptr<FileStreamWriter>
  125. SandboxFileSystemBackend::CreateFileStreamWriter(
  126. const FileSystemURL& url,
  127. int64_t offset,
  128. FileSystemContext* context) const {
  129. DCHECK(CanHandleType(url.type()));
  130. DCHECK(delegate_);
  131. return delegate_->CreateFileStreamWriter(url, offset, context, url.type());
  132. }
  133. FileSystemQuotaUtil* SandboxFileSystemBackend::GetQuotaUtil() {
  134. return delegate_;
  135. }
  136. const UpdateObserverList* SandboxFileSystemBackend::GetUpdateObservers(
  137. FileSystemType type) const {
  138. return delegate_->GetUpdateObservers(type);
  139. }
  140. const ChangeObserverList* SandboxFileSystemBackend::GetChangeObservers(
  141. FileSystemType type) const {
  142. return delegate_->GetChangeObservers(type);
  143. }
  144. const AccessObserverList* SandboxFileSystemBackend::GetAccessObservers(
  145. FileSystemType type) const {
  146. return delegate_->GetAccessObservers(type);
  147. }
  148. SandboxFileSystemBackendDelegate::StorageKeyEnumerator*
  149. SandboxFileSystemBackend::CreateStorageKeyEnumerator() {
  150. DCHECK(delegate_);
  151. return delegate_->CreateStorageKeyEnumerator();
  152. }
  153. } // namespace storage