sandbox_file_stream_reader.cc 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130
  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_stream_reader.h"
  5. #include <stdint.h>
  6. #include <utility>
  7. #include "base/memory/ptr_util.h"
  8. #include "base/memory/weak_ptr.h"
  9. #include "base/task/single_thread_task_runner.h"
  10. #include "net/base/file_stream.h"
  11. #include "net/base/io_buffer.h"
  12. #include "net/base/net_errors.h"
  13. #include "storage/browser/file_system/file_system_context.h"
  14. #include "storage/browser/file_system/file_system_operation_runner.h"
  15. #include "storage/browser/file_system/memory_file_stream_reader.h"
  16. #include "storage/browser/file_system/obfuscated_file_util_memory_delegate.h"
  17. // TODO(kinuko): Remove this temporary namespace hack after we move both
  18. // blob and fileapi into content namespace.
  19. namespace storage {
  20. SandboxFileStreamReader::SandboxFileStreamReader(
  21. FileSystemContext* file_system_context,
  22. const FileSystemURL& url,
  23. int64_t initial_offset,
  24. const base::Time& expected_modification_time)
  25. : read_buf_(nullptr),
  26. read_buf_len_(0),
  27. file_system_context_(file_system_context),
  28. url_(url),
  29. initial_offset_(initial_offset),
  30. expected_modification_time_(expected_modification_time),
  31. has_pending_create_snapshot_(false) {}
  32. SandboxFileStreamReader::~SandboxFileStreamReader() = default;
  33. int SandboxFileStreamReader::Read(net::IOBuffer* buf,
  34. int buf_len,
  35. net::CompletionOnceCallback callback) {
  36. if (file_reader_)
  37. return file_reader_->Read(buf, buf_len, std::move(callback));
  38. read_buf_ = buf;
  39. read_buf_len_ = buf_len;
  40. read_callback_ = std::move(callback);
  41. return CreateSnapshot();
  42. }
  43. int64_t SandboxFileStreamReader::GetLength(
  44. net::Int64CompletionOnceCallback callback) {
  45. if (file_reader_)
  46. return file_reader_->GetLength(std::move(callback));
  47. get_length_callback_ = std::move(callback);
  48. return CreateSnapshot();
  49. }
  50. int SandboxFileStreamReader::CreateSnapshot() {
  51. DCHECK(!has_pending_create_snapshot_);
  52. has_pending_create_snapshot_ = true;
  53. file_system_context_->operation_runner()->CreateSnapshotFile(
  54. url_, base::BindOnce(&SandboxFileStreamReader::DidCreateSnapshot,
  55. weak_factory_.GetWeakPtr()));
  56. return net::ERR_IO_PENDING;
  57. }
  58. void SandboxFileStreamReader::DidCreateSnapshot(
  59. base::File::Error file_error,
  60. const base::File::Info& file_info,
  61. const base::FilePath& platform_path,
  62. scoped_refptr<ShareableFileReference> file_ref) {
  63. DCHECK(has_pending_create_snapshot_);
  64. DCHECK(!file_reader_.get());
  65. has_pending_create_snapshot_ = false;
  66. if (file_error != base::File::FILE_OK) {
  67. if (read_callback_) {
  68. DCHECK(!get_length_callback_);
  69. std::move(read_callback_).Run(net::FileErrorToNetError(file_error));
  70. return;
  71. }
  72. std::move(get_length_callback_).Run(net::FileErrorToNetError(file_error));
  73. return;
  74. }
  75. // Keep the reference (if it's non-null) so that the file won't go away.
  76. snapshot_ref_ = std::move(file_ref);
  77. if (file_system_context_->is_incognito()) {
  78. base::WeakPtr<ObfuscatedFileUtilMemoryDelegate> memory_file_util_delegate =
  79. file_system_context_->sandbox_delegate()->memory_file_util_delegate();
  80. file_reader_ = std::make_unique<MemoryFileStreamReader>(
  81. file_system_context_->default_file_task_runner(),
  82. memory_file_util_delegate, platform_path, initial_offset_,
  83. expected_modification_time_);
  84. } else {
  85. file_reader_ = FileStreamReader::CreateForLocalFile(
  86. file_system_context_->default_file_task_runner(), platform_path,
  87. initial_offset_, expected_modification_time_);
  88. }
  89. if (read_callback_) {
  90. DCHECK(!get_length_callback_);
  91. int rv = Read(read_buf_, read_buf_len_,
  92. base::BindOnce(&SandboxFileStreamReader::OnRead,
  93. weak_factory_.GetWeakPtr()));
  94. if (rv != net::ERR_IO_PENDING)
  95. std::move(read_callback_).Run(rv);
  96. return;
  97. }
  98. int64_t rv = file_reader_->GetLength(base::BindOnce(
  99. &SandboxFileStreamReader::OnGetLength, weak_factory_.GetWeakPtr()));
  100. if (rv != net::ERR_IO_PENDING)
  101. std::move(get_length_callback_).Run(rv);
  102. }
  103. void SandboxFileStreamReader::OnRead(int rv) {
  104. std::move(read_callback_).Run(rv);
  105. }
  106. void SandboxFileStreamReader::OnGetLength(int64_t rv) {
  107. std::move(get_length_callback_).Run(rv);
  108. }
  109. } // namespace storage