OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h" | 5 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <memory> | 10 #include <memory> |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
196 std::unique_ptr<QuotaReservationManager::QuotaBackend>( | 196 std::unique_ptr<QuotaReservationManager::QuotaBackend>( |
197 new QuotaBackendImpl(file_task_runner_.get(), | 197 new QuotaBackendImpl(file_task_runner_.get(), |
198 obfuscated_file_util(), | 198 obfuscated_file_util(), |
199 usage_cache(), | 199 usage_cache(), |
200 quota_manager_proxy)))), | 200 quota_manager_proxy)))), |
201 special_storage_policy_(special_storage_policy), | 201 special_storage_policy_(special_storage_policy), |
202 file_system_options_(file_system_options), | 202 file_system_options_(file_system_options), |
203 is_filesystem_opened_(false), | 203 is_filesystem_opened_(false), |
204 weak_factory_(this) { | 204 weak_factory_(this) { |
205 // Prepopulate database only if it can run asynchronously (i.e. the current | 205 // Prepopulate database only if it can run asynchronously (i.e. the current |
206 // thread is not file_task_runner). Usually this is the case but may not | 206 // sequence is not file_task_runner). Usually this is the case but may not |
207 // in test code. | 207 // in test code. |
208 if (!file_system_options.is_incognito() && | 208 if (!file_system_options.is_incognito() && |
209 !file_task_runner_->RunsTasksOnCurrentThread()) { | 209 !file_task_runner_->RunsTasksInCurrentSequence()) { |
210 std::vector<std::string> types_to_prepopulate( | 210 std::vector<std::string> types_to_prepopulate( |
211 &kPrepopulateTypes[0], | 211 &kPrepopulateTypes[0], |
212 &kPrepopulateTypes[arraysize(kPrepopulateTypes)]); | 212 &kPrepopulateTypes[arraysize(kPrepopulateTypes)]); |
213 file_task_runner_->PostTask( | 213 file_task_runner_->PostTask( |
214 FROM_HERE, | 214 FROM_HERE, |
215 base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase, | 215 base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase, |
216 base::Unretained(obfuscated_file_util()), | 216 base::Unretained(obfuscated_file_util()), |
217 types_to_prepopulate)); | 217 types_to_prepopulate)); |
218 } | 218 } |
219 } | 219 } |
220 | 220 |
221 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() { | 221 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() { |
222 io_thread_checker_.DetachFromThread(); | 222 io_thread_checker_.DetachFromThread(); |
223 | 223 |
224 if (!file_task_runner_->RunsTasksOnCurrentThread()) { | 224 if (!file_task_runner_->RunsTasksInCurrentSequence()) { |
225 DeleteSoon(file_task_runner_.get(), quota_reservation_manager_.release()); | 225 DeleteSoon(file_task_runner_.get(), quota_reservation_manager_.release()); |
226 DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release()); | 226 DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release()); |
227 DeleteSoon(file_task_runner_.get(), quota_observer_.release()); | 227 DeleteSoon(file_task_runner_.get(), quota_observer_.release()); |
228 DeleteSoon(file_task_runner_.get(), file_system_usage_cache_.release()); | 228 DeleteSoon(file_task_runner_.get(), file_system_usage_cache_.release()); |
229 } | 229 } |
230 } | 230 } |
231 | 231 |
232 SandboxFileSystemBackendDelegate::OriginEnumerator* | 232 SandboxFileSystemBackendDelegate::OriginEnumerator* |
233 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() { | 233 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() { |
234 return new ObfuscatedOriginEnumerator(obfuscated_file_util()); | 234 return new ObfuscatedOriginEnumerator(obfuscated_file_util()); |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
324 return std::unique_ptr<FileStreamWriter>( | 324 return std::unique_ptr<FileStreamWriter>( |
325 new SandboxFileStreamWriter(context, url, offset, *observers)); | 325 new SandboxFileStreamWriter(context, url, offset, *observers)); |
326 } | 326 } |
327 | 327 |
328 base::File::Error | 328 base::File::Error |
329 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner( | 329 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner( |
330 FileSystemContext* file_system_context, | 330 FileSystemContext* file_system_context, |
331 storage::QuotaManagerProxy* proxy, | 331 storage::QuotaManagerProxy* proxy, |
332 const GURL& origin_url, | 332 const GURL& origin_url, |
333 FileSystemType type) { | 333 FileSystemType type) { |
334 DCHECK(file_task_runner_->RunsTasksOnCurrentThread()); | 334 DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); |
335 int64_t usage = | 335 int64_t usage = |
336 GetOriginUsageOnFileTaskRunner(file_system_context, origin_url, type); | 336 GetOriginUsageOnFileTaskRunner(file_system_context, origin_url, type); |
337 usage_cache()->CloseCacheFiles(); | 337 usage_cache()->CloseCacheFiles(); |
338 bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType( | 338 bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType( |
339 origin_url, GetTypeString(type)); | 339 origin_url, GetTypeString(type)); |
340 if (result && proxy) { | 340 if (result && proxy) { |
341 proxy->NotifyStorageModified(storage::QuotaClient::kFileSystem, | 341 proxy->NotifyStorageModified(storage::QuotaClient::kFileSystem, |
342 origin_url, | 342 origin_url, |
343 FileSystemTypeToQuotaStorageType(type), | 343 FileSystemTypeToQuotaStorageType(type), |
344 -usage); | 344 -usage); |
345 } | 345 } |
346 | 346 |
347 if (result) | 347 if (result) |
348 return base::File::FILE_OK; | 348 return base::File::FILE_OK; |
349 return base::File::FILE_ERROR_FAILED; | 349 return base::File::FILE_ERROR_FAILED; |
350 } | 350 } |
351 | 351 |
352 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner( | 352 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner( |
353 FileSystemType type, std::set<GURL>* origins) { | 353 FileSystemType type, std::set<GURL>* origins) { |
354 DCHECK(file_task_runner_->RunsTasksOnCurrentThread()); | 354 DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); |
355 DCHECK(origins); | 355 DCHECK(origins); |
356 std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator()); | 356 std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator()); |
357 GURL origin; | 357 GURL origin; |
358 while (!(origin = enumerator->Next()).is_empty()) { | 358 while (!(origin = enumerator->Next()).is_empty()) { |
359 if (enumerator->HasFileSystemType(type)) | 359 if (enumerator->HasFileSystemType(type)) |
360 origins->insert(origin); | 360 origins->insert(origin); |
361 } | 361 } |
362 switch (type) { | 362 switch (type) { |
363 case kFileSystemTypeTemporary: | 363 case kFileSystemTypeTemporary: |
364 UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size()); | 364 UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size()); |
365 break; | 365 break; |
366 case kFileSystemTypePersistent: | 366 case kFileSystemTypePersistent: |
367 UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size()); | 367 UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size()); |
368 break; | 368 break; |
369 default: | 369 default: |
370 break; | 370 break; |
371 } | 371 } |
372 } | 372 } |
373 | 373 |
374 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileTaskRunner( | 374 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileTaskRunner( |
375 FileSystemType type, const std::string& host, | 375 FileSystemType type, const std::string& host, |
376 std::set<GURL>* origins) { | 376 std::set<GURL>* origins) { |
377 DCHECK(file_task_runner_->RunsTasksOnCurrentThread()); | 377 DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); |
378 DCHECK(origins); | 378 DCHECK(origins); |
379 std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator()); | 379 std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator()); |
380 GURL origin; | 380 GURL origin; |
381 while (!(origin = enumerator->Next()).is_empty()) { | 381 while (!(origin = enumerator->Next()).is_empty()) { |
382 if (host == net::GetHostOrSpecFromURL(origin) && | 382 if (host == net::GetHostOrSpecFromURL(origin) && |
383 enumerator->HasFileSystemType(type)) | 383 enumerator->HasFileSystemType(type)) |
384 origins->insert(origin); | 384 origins->insert(origin); |
385 } | 385 } |
386 } | 386 } |
387 | 387 |
388 int64_t SandboxFileSystemBackendDelegate::GetOriginUsageOnFileTaskRunner( | 388 int64_t SandboxFileSystemBackendDelegate::GetOriginUsageOnFileTaskRunner( |
389 FileSystemContext* file_system_context, | 389 FileSystemContext* file_system_context, |
390 const GURL& origin_url, | 390 const GURL& origin_url, |
391 FileSystemType type) { | 391 FileSystemType type) { |
392 DCHECK(file_task_runner_->RunsTasksOnCurrentThread()); | 392 DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); |
393 | 393 |
394 // Don't use usage cache and return recalculated usage for sticky invalidated | 394 // Don't use usage cache and return recalculated usage for sticky invalidated |
395 // origins. | 395 // origins. |
396 if (base::ContainsKey(sticky_dirty_origins_, | 396 if (base::ContainsKey(sticky_dirty_origins_, |
397 std::make_pair(origin_url, type))) | 397 std::make_pair(origin_url, type))) |
398 return RecalculateUsage(file_system_context, origin_url, type); | 398 return RecalculateUsage(file_system_context, origin_url, type); |
399 | 399 |
400 base::FilePath base_path = | 400 base::FilePath base_path = |
401 GetBaseDirectoryForOriginAndType(origin_url, type, false); | 401 GetBaseDirectoryForOriginAndType(origin_url, type, false); |
402 if (base_path.empty() || !base::DirectoryExists(base_path)) | 402 if (base_path.empty() || !base::DirectoryExists(base_path)) |
(...skipping 20 matching lines...) Expand all Loading... |
423 | 423 |
424 // This clears the dirty flag too. | 424 // This clears the dirty flag too. |
425 usage_cache()->UpdateUsage(usage_file_path, usage); | 425 usage_cache()->UpdateUsage(usage_file_path, usage); |
426 return usage; | 426 return usage; |
427 } | 427 } |
428 | 428 |
429 scoped_refptr<QuotaReservation> | 429 scoped_refptr<QuotaReservation> |
430 SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner( | 430 SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner( |
431 const GURL& origin, | 431 const GURL& origin, |
432 FileSystemType type) { | 432 FileSystemType type) { |
433 DCHECK(file_task_runner_->RunsTasksOnCurrentThread()); | 433 DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); |
434 DCHECK(quota_reservation_manager_); | 434 DCHECK(quota_reservation_manager_); |
435 return quota_reservation_manager_->CreateReservation(origin, type); | 435 return quota_reservation_manager_->CreateReservation(origin, type); |
436 } | 436 } |
437 | 437 |
438 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver( | 438 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver( |
439 FileSystemType type, | 439 FileSystemType type, |
440 FileUpdateObserver* observer, | 440 FileUpdateObserver* observer, |
441 base::SequencedTaskRunner* task_runner) { | 441 base::SequencedTaskRunner* task_runner) { |
442 DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread()); | 442 DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread()); |
443 update_observers_[type] = | 443 update_observers_[type] = |
(...skipping 207 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
651 REPORT(kUnknownError); | 651 REPORT(kUnknownError); |
652 break; | 652 break; |
653 } | 653 } |
654 #undef REPORT | 654 #undef REPORT |
655 } | 655 } |
656 | 656 |
657 void SandboxFileSystemBackendDelegate::CopyFileSystem( | 657 void SandboxFileSystemBackendDelegate::CopyFileSystem( |
658 const GURL& origin_url, | 658 const GURL& origin_url, |
659 FileSystemType type, | 659 FileSystemType type, |
660 SandboxFileSystemBackendDelegate* destination) { | 660 SandboxFileSystemBackendDelegate* destination) { |
661 DCHECK(file_task_runner()->RunsTasksOnCurrentThread()); | 661 DCHECK(file_task_runner()->RunsTasksInCurrentSequence()); |
662 | 662 |
663 base::FilePath base_path = | 663 base::FilePath base_path = |
664 GetBaseDirectoryForOriginAndType(origin_url, type, false /* create */); | 664 GetBaseDirectoryForOriginAndType(origin_url, type, false /* create */); |
665 if (base::PathExists(base_path)) { | 665 if (base::PathExists(base_path)) { |
666 // Delete any existing file system directories in the destination. A | 666 // Delete any existing file system directories in the destination. A |
667 // previously failed migration | 667 // previously failed migration |
668 // may have left behind partially copied directories. | 668 // may have left behind partially copied directories. |
669 base::FilePath dest_path = destination->GetBaseDirectoryForOriginAndType( | 669 base::FilePath dest_path = destination->GetBaseDirectoryForOriginAndType( |
670 origin_url, type, false /* create */); | 670 origin_url, type, false /* create */); |
671 | 671 |
(...skipping 24 matching lines...) Expand all Loading... |
696 return new ObfuscatedFileUtil(special_storage_policy, | 696 return new ObfuscatedFileUtil(special_storage_policy, |
697 file_system_directory, | 697 file_system_directory, |
698 env_override, | 698 env_override, |
699 file_task_runner, | 699 file_task_runner, |
700 base::Bind(&GetTypeStringForURL), | 700 base::Bind(&GetTypeStringForURL), |
701 GetKnownTypeStrings(), | 701 GetKnownTypeStrings(), |
702 NULL); | 702 NULL); |
703 } | 703 } |
704 | 704 |
705 } // namespace storage | 705 } // namespace storage |
OLD | NEW |