Home | History | Annotate | Download | only in fileapi 
      1 // Copyright 2013 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/sandbox_file_system_backend_delegate.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/command_line.h"
     10 #include "base/file_util.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/stl_util.h"
     13 #include "base/task_runner_util.h"
     14 #include "net/base/net_util.h"
     15 #include "webkit/browser/blob/file_stream_reader.h"
     16 #include "webkit/browser/fileapi/async_file_util_adapter.h"
     17 #include "webkit/browser/fileapi/file_system_context.h"
     18 #include "webkit/browser/fileapi/file_system_operation_context.h"
     19 #include "webkit/browser/fileapi/file_system_url.h"
     20 #include "webkit/browser/fileapi/file_system_usage_cache.h"
     21 #include "webkit/browser/fileapi/obfuscated_file_util.h"
     22 #include "webkit/browser/fileapi/quota/quota_backend_impl.h"
     23 #include "webkit/browser/fileapi/quota/quota_reservation.h"
     24 #include "webkit/browser/fileapi/quota/quota_reservation_manager.h"
     25 #include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
     26 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
     27 #include "webkit/browser/fileapi/sandbox_quota_observer.h"
     28 #include "webkit/browser/quota/quota_manager_proxy.h"
     29 #include "webkit/common/fileapi/file_system_util.h"
     30 
     31 namespace fileapi {
     32 
     33 namespace {
     34 
     35 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
     36 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
     37 
     38 const char kOpenFileSystemLabel[] = "FileSystem.OpenFileSystem";
     39 const char kOpenFileSystemDetailLabel[] = "FileSystem.OpenFileSystemDetail";
     40 const char kOpenFileSystemDetailNonThrottledLabel[] =
     41     "FileSystem.OpenFileSystemDetailNonthrottled";
     42 int64 kMinimumStatsCollectionIntervalHours = 1;
     43 
     44 // For type directory names in ObfuscatedFileUtil.
     45 // TODO(kinuko,nhiroki): Each type string registration should be done
     46 // via its own backend.
     47 const char kTemporaryDirectoryName[] = "t";
     48 const char kPersistentDirectoryName[] = "p";
     49 const char kSyncableDirectoryName[] = "s";
     50 
     51 const char* kPrepopulateTypes[] = {
     52   kPersistentDirectoryName,
     53   kTemporaryDirectoryName
     54 };
     55 
     56 enum FileSystemError {
     57   kOK = 0,
     58   kIncognito,
     59   kInvalidSchemeError,
     60   kCreateDirectoryError,
     61   kNotFound,
     62   kUnknownError,
     63   kFileSystemErrorMax,
     64 };
     65 
     66 // Restricted names.
     67 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
     68 const base::FilePath::CharType* const kRestrictedNames[] = {
     69   FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
     70 };
     71 
     72 // Restricted chars.
     73 const base::FilePath::CharType kRestrictedChars[] = {
     74   FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
     75 };
     76 
     77 std::string GetTypeStringForURL(const FileSystemURL& url) {
     78   return SandboxFileSystemBackendDelegate::GetTypeString(url.type());
     79 }
     80 
     81 std::set<std::string> GetKnownTypeStrings() {
     82   std::set<std::string> known_type_strings;
     83   known_type_strings.insert(kTemporaryDirectoryName);
     84   known_type_strings.insert(kPersistentDirectoryName);
     85   known_type_strings.insert(kSyncableDirectoryName);
     86   return known_type_strings;
     87 }
     88 
     89 class ObfuscatedOriginEnumerator
     90     : public SandboxFileSystemBackendDelegate::OriginEnumerator {
     91  public:
     92   explicit ObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
     93     enum_.reset(file_util->CreateOriginEnumerator());
     94   }
     95   virtual ~ObfuscatedOriginEnumerator() {}
     96 
     97   virtual GURL Next() OVERRIDE {
     98     return enum_->Next();
     99   }
    100 
    101   virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
    102     return enum_->HasTypeDirectory(
    103         SandboxFileSystemBackendDelegate::GetTypeString(type));
    104   }
    105 
    106  private:
    107   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
    108 };
    109 
    110 void OpenFileSystemOnFileTaskRunner(
    111     ObfuscatedFileUtil* file_util,
    112     const GURL& origin_url,
    113     FileSystemType type,
    114     OpenFileSystemMode mode,
    115     base::File::Error* error_ptr) {
    116   DCHECK(error_ptr);
    117   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
    118   file_util->GetDirectoryForOriginAndType(
    119       origin_url, SandboxFileSystemBackendDelegate::GetTypeString(type),
    120       create, error_ptr);
    121   if (*error_ptr != base::File::FILE_OK) {
    122     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
    123                               kCreateDirectoryError,
    124                               kFileSystemErrorMax);
    125   } else {
    126     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
    127   }
    128   // The reference of file_util will be derefed on the FILE thread
    129   // when the storage of this callback gets deleted regardless of whether
    130   // this method is called or not.
    131 }
    132 
    133 void DidOpenFileSystem(
    134     base::WeakPtr<SandboxFileSystemBackendDelegate> delegate,
    135     const base::Callback<void(base::File::Error error)>& callback,
    136     base::File::Error* error) {
    137   if (delegate.get())
    138     delegate.get()->CollectOpenFileSystemMetrics(*error);
    139   callback.Run(*error);
    140 }
    141 
    142 template <typename T>
    143 void DeleteSoon(base::SequencedTaskRunner* runner, T* ptr) {
    144   if (!runner->DeleteSoon(FROM_HERE, ptr))
    145     delete ptr;
    146 }
    147 
    148 }  // namespace
    149 
    150 const base::FilePath::CharType
    151 SandboxFileSystemBackendDelegate::kFileSystemDirectory[] =
    152     FILE_PATH_LITERAL("File System");
    153 
    154 // static
    155 std::string SandboxFileSystemBackendDelegate::GetTypeString(
    156     FileSystemType type) {
    157   switch (type) {
    158     case kFileSystemTypeTemporary:
    159       return kTemporaryDirectoryName;
    160     case kFileSystemTypePersistent:
    161       return kPersistentDirectoryName;
    162     case kFileSystemTypeSyncable:
    163     case kFileSystemTypeSyncableForInternalSync:
    164       return kSyncableDirectoryName;
    165     case kFileSystemTypeUnknown:
    166     default:
    167       NOTREACHED() << "Unknown filesystem type requested:" << type;
    168       return std::string();
    169   }
    170 }
    171 
    172 SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate(
    173     quota::QuotaManagerProxy* quota_manager_proxy,
    174     base::SequencedTaskRunner* file_task_runner,
    175     const base::FilePath& profile_path,
    176     quota::SpecialStoragePolicy* special_storage_policy,
    177     const FileSystemOptions& file_system_options)
    178     : file_task_runner_(file_task_runner),
    179       sandbox_file_util_(new AsyncFileUtilAdapter(
    180           new ObfuscatedFileUtil(
    181               special_storage_policy,
    182               profile_path.Append(kFileSystemDirectory),
    183               file_system_options.env_override(),
    184               file_task_runner,
    185               base::Bind(&GetTypeStringForURL),
    186               GetKnownTypeStrings(),
    187               this))),
    188       file_system_usage_cache_(new FileSystemUsageCache(file_task_runner)),
    189       quota_observer_(new SandboxQuotaObserver(
    190           quota_manager_proxy,
    191           file_task_runner,
    192           obfuscated_file_util(),
    193           usage_cache())),
    194       quota_reservation_manager_(new QuotaReservationManager(
    195           scoped_ptr<QuotaReservationManager::QuotaBackend>(
    196               new QuotaBackendImpl(file_task_runner_,
    197                                    obfuscated_file_util(),
    198                                    usage_cache(),
    199                                    quota_manager_proxy)))),
    200       special_storage_policy_(special_storage_policy),
    201       file_system_options_(file_system_options),
    202       is_filesystem_opened_(false),
    203       weak_factory_(this) {
    204   // Prepopulate database only if it can run asynchronously (i.e. the current
    205   // thread is not file_task_runner). Usually this is the case but may not
    206   // in test code.
    207   if (!file_system_options.is_incognito() &&
    208       !file_task_runner_->RunsTasksOnCurrentThread()) {
    209     std::vector<std::string> types_to_prepopulate(
    210         &kPrepopulateTypes[0],
    211         &kPrepopulateTypes[arraysize(kPrepopulateTypes)]);
    212     file_task_runner_->PostTask(
    213         FROM_HERE,
    214         base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
    215                   base::Unretained(obfuscated_file_util()),
    216                   types_to_prepopulate));
    217   }
    218 }
    219 
    220 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() {
    221   io_thread_checker_.DetachFromThread();
    222 
    223   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
    224     DeleteSoon(file_task_runner_.get(), quota_reservation_manager_.release());
    225     DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release());
    226     DeleteSoon(file_task_runner_.get(), quota_observer_.release());
    227     DeleteSoon(file_task_runner_.get(), file_system_usage_cache_.release());
    228   }
    229 }
    230 
    231 SandboxFileSystemBackendDelegate::OriginEnumerator*
    232 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() {
    233   return new ObfuscatedOriginEnumerator(obfuscated_file_util());
    234 }
    235 
    236 base::FilePath
    237 SandboxFileSystemBackendDelegate::GetBaseDirectoryForOriginAndType(
    238     const GURL& origin_url,
    239     FileSystemType type,
    240     bool create) {
    241   base::File::Error error = base::File::FILE_OK;
    242   base::FilePath path = obfuscated_file_util()->GetDirectoryForOriginAndType(
    243       origin_url, GetTypeString(type), create, &error);
    244   if (error != base::File::FILE_OK)
    245     return base::FilePath();
    246   return path;
    247 }
    248 
    249 void SandboxFileSystemBackendDelegate::OpenFileSystem(
    250     const GURL& origin_url,
    251     FileSystemType type,
    252     OpenFileSystemMode mode,
    253     const OpenFileSystemCallback& callback,
    254     const GURL& root_url) {
    255   if (!IsAllowedScheme(origin_url)) {
    256     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
    257     return;
    258   }
    259 
    260   std::string name = GetFileSystemName(origin_url, type);
    261 
    262   base::File::Error* error_ptr = new base::File::Error;
    263   file_task_runner_->PostTaskAndReply(
    264       FROM_HERE,
    265       base::Bind(&OpenFileSystemOnFileTaskRunner,
    266                  obfuscated_file_util(), origin_url, type, mode,
    267                  base::Unretained(error_ptr)),
    268       base::Bind(&DidOpenFileSystem,
    269                  weak_factory_.GetWeakPtr(),
    270                  base::Bind(callback, root_url, name),
    271                  base::Owned(error_ptr)));
    272 
    273   io_thread_checker_.DetachFromThread();
    274   is_filesystem_opened_ = true;
    275 }
    276 
    277 scoped_ptr<FileSystemOperationContext>
    278 SandboxFileSystemBackendDelegate::CreateFileSystemOperationContext(
    279     const FileSystemURL& url,
    280     FileSystemContext* context,
    281     base::File::Error* error_code) const {
    282   if (!IsAccessValid(url)) {
    283     *error_code = base::File::FILE_ERROR_SECURITY;
    284     return scoped_ptr<FileSystemOperationContext>();
    285   }
    286 
    287   const UpdateObserverList* update_observers = GetUpdateObservers(url.type());
    288   const ChangeObserverList* change_observers = GetChangeObservers(url.type());
    289   DCHECK(update_observers);
    290 
    291   scoped_ptr<FileSystemOperationContext> operation_context(
    292       new FileSystemOperationContext(context));
    293   operation_context->set_update_observers(*update_observers);
    294   operation_context->set_change_observers(
    295       change_observers ? *change_observers : ChangeObserverList());
    296 
    297   return operation_context.Pass();
    298 }
    299 
    300 scoped_ptr<webkit_blob::FileStreamReader>
    301 SandboxFileSystemBackendDelegate::CreateFileStreamReader(
    302     const FileSystemURL& url,
    303     int64 offset,
    304     const base::Time& expected_modification_time,
    305     FileSystemContext* context) const {
    306   if (!IsAccessValid(url))
    307     return scoped_ptr<webkit_blob::FileStreamReader>();
    308   return scoped_ptr<webkit_blob::FileStreamReader>(
    309       webkit_blob::FileStreamReader::CreateForFileSystemFile(
    310           context, url, offset, expected_modification_time));
    311 }
    312 
    313 scoped_ptr<FileStreamWriter>
    314 SandboxFileSystemBackendDelegate::CreateFileStreamWriter(
    315     const FileSystemURL& url,
    316     int64 offset,
    317     FileSystemContext* context,
    318     FileSystemType type) const {
    319   if (!IsAccessValid(url))
    320     return scoped_ptr<FileStreamWriter>();
    321   const UpdateObserverList* observers = GetUpdateObservers(type);
    322   DCHECK(observers);
    323   return scoped_ptr<FileStreamWriter>(
    324       new SandboxFileStreamWriter(context, url, offset, *observers));
    325 }
    326 
    327 base::File::Error
    328 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
    329     FileSystemContext* file_system_context,
    330     quota::QuotaManagerProxy* proxy,
    331     const GURL& origin_url,
    332     FileSystemType type) {
    333   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
    334   int64 usage = GetOriginUsageOnFileTaskRunner(
    335       file_system_context, origin_url, type);
    336   usage_cache()->CloseCacheFiles();
    337   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
    338       origin_url, GetTypeString(type));
    339   if (result && proxy) {
    340     proxy->NotifyStorageModified(
    341         quota::QuotaClient::kFileSystem,
    342         origin_url,
    343         FileSystemTypeToQuotaStorageType(type),
    344         -usage);
    345   }
    346 
    347   if (result)
    348     return base::File::FILE_OK;
    349   return base::File::FILE_ERROR_FAILED;
    350 }
    351 
    352 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
    353     FileSystemType type, std::set<GURL>* origins) {
    354   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
    355   DCHECK(origins);
    356   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
    357   GURL origin;
    358   while (!(origin = enumerator->Next()).is_empty()) {
    359     if (enumerator->HasFileSystemType(type))
    360       origins->insert(origin);
    361   }
    362   switch (type) {
    363     case kFileSystemTypeTemporary:
    364       UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
    365       break;
    366     case kFileSystemTypePersistent:
    367       UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
    368       break;
    369     default:
    370       break;
    371   }
    372 }
    373 
    374 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileTaskRunner(
    375     FileSystemType type, const std::string& host,
    376     std::set<GURL>* origins) {
    377   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
    378   DCHECK(origins);
    379   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
    380   GURL origin;
    381   while (!(origin = enumerator->Next()).is_empty()) {
    382     if (host == net::GetHostOrSpecFromURL(origin) &&
    383         enumerator->HasFileSystemType(type))
    384       origins->insert(origin);
    385   }
    386 }
    387 
    388 int64 SandboxFileSystemBackendDelegate::GetOriginUsageOnFileTaskRunner(
    389     FileSystemContext* file_system_context,
    390     const GURL& origin_url,
    391     FileSystemType type) {
    392   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
    393 
    394   // Don't use usage cache and return recalculated usage for sticky invalidated
    395   // origins.
    396   if (ContainsKey(sticky_dirty_origins_, std::make_pair(origin_url, type)))
    397     return RecalculateUsage(file_system_context, origin_url, type);
    398 
    399   base::FilePath base_path =
    400       GetBaseDirectoryForOriginAndType(origin_url, type, false);
    401   if (base_path.empty() || !base::DirectoryExists(base_path))
    402     return 0;
    403   base::FilePath usage_file_path =
    404       base_path.Append(FileSystemUsageCache::kUsageFileName);
    405 
    406   bool is_valid = usage_cache()->IsValid(usage_file_path);
    407   uint32 dirty_status = 0;
    408   bool dirty_status_available =
    409       usage_cache()->GetDirty(usage_file_path, &dirty_status);
    410   bool visited = !visited_origins_.insert(origin_url).second;
    411   if (is_valid && (dirty_status == 0 || (dirty_status_available && visited))) {
    412     // The usage cache is clean (dirty == 0) or the origin is already
    413     // initialized and running.  Read the cache file to get the usage.
    414     int64 usage = 0;
    415     return usage_cache()->GetUsage(usage_file_path, &usage) ? usage : -1;
    416   }
    417   // The usage cache has not been initialized or the cache is dirty.
    418   // Get the directory size now and update the cache.
    419   usage_cache()->Delete(usage_file_path);
    420 
    421   int64 usage = RecalculateUsage(file_system_context, origin_url, type);
    422 
    423   // This clears the dirty flag too.
    424   usage_cache()->UpdateUsage(usage_file_path, usage);
    425   return usage;
    426 }
    427 
    428 scoped_refptr<QuotaReservation>
    429 SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner(
    430     const GURL& origin,
    431     FileSystemType type) {
    432   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
    433   DCHECK(quota_reservation_manager_);
    434   return quota_reservation_manager_->CreateReservation(origin, type);
    435 }
    436 
    437 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver(
    438     FileSystemType type,
    439     FileUpdateObserver* observer,
    440     base::SequencedTaskRunner* task_runner) {
    441   DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread());
    442   update_observers_[type] =
    443       update_observers_[type].AddObserver(observer, task_runner);
    444 }
    445 
    446 void SandboxFileSystemBackendDelegate::AddFileChangeObserver(
    447     FileSystemType type,
    448     FileChangeObserver* observer,
    449     base::SequencedTaskRunner* task_runner) {
    450   DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread());
    451   change_observers_[type] =
    452       change_observers_[type].AddObserver(observer, task_runner);
    453 }
    454 
    455 void SandboxFileSystemBackendDelegate::AddFileAccessObserver(
    456     FileSystemType type,
    457     FileAccessObserver* observer,
    458     base::SequencedTaskRunner* task_runner) {
    459   DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread());
    460   access_observers_[type] =
    461       access_observers_[type].AddObserver(observer, task_runner);
    462 }
    463 
    464 const UpdateObserverList* SandboxFileSystemBackendDelegate::GetUpdateObservers(
    465     FileSystemType type) const {
    466   std::map<FileSystemType, UpdateObserverList>::const_iterator iter =
    467       update_observers_.find(type);
    468   if (iter == update_observers_.end())
    469     return NULL;
    470   return &iter->second;
    471 }
    472 
    473 const ChangeObserverList* SandboxFileSystemBackendDelegate::GetChangeObservers(
    474     FileSystemType type) const {
    475   std::map<FileSystemType, ChangeObserverList>::const_iterator iter =
    476       change_observers_.find(type);
    477   if (iter == change_observers_.end())
    478     return NULL;
    479   return &iter->second;
    480 }
    481 
    482 const AccessObserverList* SandboxFileSystemBackendDelegate::GetAccessObservers(
    483     FileSystemType type) const {
    484   std::map<FileSystemType, AccessObserverList>::const_iterator iter =
    485       access_observers_.find(type);
    486   if (iter == access_observers_.end())
    487     return NULL;
    488   return &iter->second;
    489 }
    490 
    491 void SandboxFileSystemBackendDelegate::RegisterQuotaUpdateObserver(
    492     FileSystemType type) {
    493   AddFileUpdateObserver(type, quota_observer_.get(), file_task_runner_.get());
    494 }
    495 
    496 void SandboxFileSystemBackendDelegate::InvalidateUsageCache(
    497     const GURL& origin,
    498     FileSystemType type) {
    499   base::File::Error error = base::File::FILE_OK;
    500   base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
    501       obfuscated_file_util(), origin, type, &error);
    502   if (error != base::File::FILE_OK)
    503     return;
    504   usage_cache()->IncrementDirty(usage_file_path);
    505 }
    506 
    507 void SandboxFileSystemBackendDelegate::StickyInvalidateUsageCache(
    508     const GURL& origin,
    509     FileSystemType type) {
    510   sticky_dirty_origins_.insert(std::make_pair(origin, type));
    511   quota_observer()->SetUsageCacheEnabled(origin, type, false);
    512   InvalidateUsageCache(origin, type);
    513 }
    514 
    515 FileSystemFileUtil* SandboxFileSystemBackendDelegate::sync_file_util() {
    516   return static_cast<AsyncFileUtilAdapter*>(file_util())->sync_file_util();
    517 }
    518 
    519 bool SandboxFileSystemBackendDelegate::IsAccessValid(
    520     const FileSystemURL& url) const {
    521   if (!IsAllowedScheme(url.origin()))
    522     return false;
    523 
    524   if (url.path().ReferencesParent())
    525     return false;
    526 
    527   // Return earlier if the path is '/', because VirtualPath::BaseName()
    528   // returns '/' for '/' and we fail the "basename != '/'" check below.
    529   // (We exclude '.' because it's disallowed by spec.)
    530   if (VirtualPath::IsRootPath(url.path()) &&
    531       url.path() != base::FilePath(base::FilePath::kCurrentDirectory))
    532     return true;
    533 
    534   // Restricted names specified in
    535   // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
    536   base::FilePath filename = VirtualPath::BaseName(url.path());
    537   // See if the name is allowed to create.
    538   for (size_t i = 0; i < arraysize(kRestrictedNames); ++i) {
    539     if (filename.value() == kRestrictedNames[i])
    540       return false;
    541   }
    542   for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
    543     if (filename.value().find(kRestrictedChars[i]) !=
    544         base::FilePath::StringType::npos)
    545       return false;
    546   }
    547 
    548   return true;
    549 }
    550 
    551 bool SandboxFileSystemBackendDelegate::IsAllowedScheme(const GURL& url) const {
    552   // Basically we only accept http or https. We allow file:// URLs
    553   // only if --allow-file-access-from-files flag is given.
    554   if (url.SchemeIsHTTPOrHTTPS())
    555     return true;
    556   if (url.SchemeIsFileSystem())
    557     return url.inner_url() && IsAllowedScheme(*url.inner_url());
    558 
    559   for (size_t i = 0;
    560        i < file_system_options_.additional_allowed_schemes().size();
    561        ++i) {
    562     if (url.SchemeIs(
    563             file_system_options_.additional_allowed_schemes()[i].c_str()))
    564       return true;
    565   }
    566   return false;
    567 }
    568 
    569 base::FilePath
    570 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
    571     const GURL& origin_url,
    572     FileSystemType type) {
    573   base::File::Error error;
    574   base::FilePath path = GetUsageCachePathForOriginAndType(
    575       obfuscated_file_util(), origin_url, type, &error);
    576   if (error != base::File::FILE_OK)
    577     return base::FilePath();
    578   return path;
    579 }
    580 
    581 // static
    582 base::FilePath
    583 SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
    584     ObfuscatedFileUtil* sandbox_file_util,
    585     const GURL& origin_url,
    586     FileSystemType type,
    587     base::File::Error* error_out) {
    588   DCHECK(error_out);
    589   *error_out = base::File::FILE_OK;
    590   base::FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
    591       origin_url, GetTypeString(type), false /* create */, error_out);
    592   if (*error_out != base::File::FILE_OK)
    593     return base::FilePath();
    594   return base_path.Append(FileSystemUsageCache::kUsageFileName);
    595 }
    596 
    597 int64 SandboxFileSystemBackendDelegate::RecalculateUsage(
    598     FileSystemContext* context,
    599     const GURL& origin,
    600     FileSystemType type) {
    601   FileSystemOperationContext operation_context(context);
    602   FileSystemURL url = context->CreateCrackedFileSystemURL(
    603       origin, type, base::FilePath());
    604   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
    605       obfuscated_file_util()->CreateFileEnumerator(
    606           &operation_context, url, true));
    607 
    608   base::FilePath file_path_each;
    609   int64 usage = 0;
    610 
    611   while (!(file_path_each = enumerator->Next()).empty()) {
    612     usage += enumerator->Size();
    613     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
    614   }
    615 
    616   return usage;
    617 }
    618 
    619 void SandboxFileSystemBackendDelegate::CollectOpenFileSystemMetrics(
    620     base::File::Error error_code) {
    621   base::Time now = base::Time::Now();
    622   bool throttled = now < next_release_time_for_open_filesystem_stat_;
    623   if (!throttled) {
    624     next_release_time_for_open_filesystem_stat_ =
    625         now + base::TimeDelta::FromHours(kMinimumStatsCollectionIntervalHours);
    626   }
    627 
    628 #define REPORT(report_value)                                            \
    629   UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailLabel,                 \
    630                             (report_value),                             \
    631                             kFileSystemErrorMax);                       \
    632   if (!throttled) {                                                     \
    633     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemDetailNonThrottledLabel,   \
    634                               (report_value),                           \
    635                               kFileSystemErrorMax);                     \
    636   }
    637 
    638   switch (error_code) {
    639     case base::File::FILE_OK:
    640       REPORT(kOK);
    641       break;
    642     case base::File::FILE_ERROR_INVALID_URL:
    643       REPORT(kInvalidSchemeError);
    644       break;
    645     case base::File::FILE_ERROR_NOT_FOUND:
    646       REPORT(kNotFound);
    647       break;
    648     case base::File::FILE_ERROR_FAILED:
    649     default:
    650       REPORT(kUnknownError);
    651       break;
    652   }
    653 #undef REPORT
    654 }
    655 
    656 ObfuscatedFileUtil* SandboxFileSystemBackendDelegate::obfuscated_file_util() {
    657   return static_cast<ObfuscatedFileUtil*>(sync_file_util());
    658 }
    659 
    660 // Declared in obfuscated_file_util.h.
    661 // static
    662 ObfuscatedFileUtil* ObfuscatedFileUtil::CreateForTesting(
    663     quota::SpecialStoragePolicy* special_storage_policy,
    664     const base::FilePath& file_system_directory,
    665     leveldb::Env* env_override,
    666     base::SequencedTaskRunner* file_task_runner) {
    667   return new ObfuscatedFileUtil(special_storage_policy,
    668                                 file_system_directory,
    669                                 env_override,
    670                                 file_task_runner,
    671                                 base::Bind(&GetTypeStringForURL),
    672                                 GetKnownTypeStrings(),
    673                                 NULL);
    674 }
    675 
    676 }  // namespace fileapi
    677