1 // Copyright 2012 The Chromium Authors
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 "net/disk_cache/blockfile/file.h"
6
7 #include <stdint.h>
8
9 #include <limits>
10 #include <utility>
11
12 #include "base/check.h"
13 #include "base/compiler_specific.h"
14 #include "base/functional/bind.h"
15 #include "base/location.h"
16 #include "base/run_loop.h"
17 #include "base/task/thread_pool.h"
18 #include "base/task/thread_pool/thread_pool_instance.h"
19 #include "net/base/net_errors.h"
20 #include "net/disk_cache/disk_cache.h"
21
22 namespace disk_cache {
23
File(base::File file)24 File::File(base::File file)
25 : init_(true), mixed_(true), base_file_(std::move(file)) {}
26
Init(const base::FilePath & name)27 bool File::Init(const base::FilePath& name) {
28 if (base_file_.IsValid())
29 return false;
30
31 int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
32 base::File::FLAG_WRITE;
33 base_file_.Initialize(name, flags);
34 return base_file_.IsValid();
35 }
36
IsValid() const37 bool File::IsValid() const {
38 return base_file_.IsValid();
39 }
40
Read(void * buffer,size_t buffer_len,size_t offset)41 bool File::Read(void* buffer, size_t buffer_len, size_t offset) {
42 DCHECK(base_file_.IsValid());
43 if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
44 offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
45 return false;
46 }
47
48 int ret = UNSAFE_TODO(
49 base_file_.Read(offset, static_cast<char*>(buffer), buffer_len));
50 return (static_cast<size_t>(ret) == buffer_len);
51 }
52
Write(const void * buffer,size_t buffer_len,size_t offset)53 bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
54 DCHECK(base_file_.IsValid());
55 if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
56 offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
57 return false;
58 }
59
60 int ret = UNSAFE_TODO(
61 base_file_.Write(offset, static_cast<const char*>(buffer), buffer_len));
62 return (static_cast<size_t>(ret) == buffer_len);
63 }
64
Read(void * buffer,size_t buffer_len,size_t offset,FileIOCallback * callback,bool * completed)65 bool File::Read(void* buffer, size_t buffer_len, size_t offset,
66 FileIOCallback* callback, bool* completed) {
67 DCHECK(base_file_.IsValid());
68 if (!callback) {
69 if (completed)
70 *completed = true;
71 return Read(buffer, buffer_len, offset);
72 }
73
74 if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
75 offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
76 return false;
77 }
78
79 base::ThreadPool::PostTaskAndReplyWithResult(
80 FROM_HERE, {base::TaskPriority::USER_BLOCKING, base::MayBlock()},
81 base::BindOnce(&File::DoRead, base::Unretained(this), buffer, buffer_len,
82 offset),
83 base::BindOnce(&File::OnOperationComplete, this, callback));
84
85 *completed = false;
86 return true;
87 }
88
Write(const void * buffer,size_t buffer_len,size_t offset,FileIOCallback * callback,bool * completed)89 bool File::Write(const void* buffer, size_t buffer_len, size_t offset,
90 FileIOCallback* callback, bool* completed) {
91 DCHECK(base_file_.IsValid());
92 if (!callback) {
93 if (completed)
94 *completed = true;
95 return Write(buffer, buffer_len, offset);
96 }
97
98 if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
99 offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
100 return false;
101 }
102
103 // The priority is USER_BLOCKING because the cache waits for the write to
104 // finish before it reads from the network again.
105 // TODO(fdoray): Consider removing this from the critical path of network
106 // requests and changing the priority to BACKGROUND.
107 base::ThreadPool::PostTaskAndReplyWithResult(
108 FROM_HERE, {base::TaskPriority::USER_BLOCKING, base::MayBlock()},
109 base::BindOnce(&File::DoWrite, base::Unretained(this), buffer, buffer_len,
110 offset),
111 base::BindOnce(&File::OnOperationComplete, this, callback));
112
113 *completed = false;
114 return true;
115 }
116
SetLength(size_t length)117 bool File::SetLength(size_t length) {
118 DCHECK(base_file_.IsValid());
119 if (length > std::numeric_limits<uint32_t>::max())
120 return false;
121
122 return base_file_.SetLength(length);
123 }
124
GetLength()125 size_t File::GetLength() {
126 DCHECK(base_file_.IsValid());
127 int64_t len = base_file_.GetLength();
128
129 if (len < 0)
130 return 0;
131 if (len > static_cast<int64_t>(std::numeric_limits<uint32_t>::max()))
132 return std::numeric_limits<uint32_t>::max();
133
134 return static_cast<size_t>(len);
135 }
136
137 // Static.
WaitForPendingIOForTesting(int * num_pending_io)138 void File::WaitForPendingIOForTesting(int* num_pending_io) {
139 // We are running unit tests so we should wait for all callbacks.
140
141 // This waits for callbacks running on worker threads.
142 base::ThreadPoolInstance::Get()->FlushForTesting();
143 // This waits for the "Reply" tasks running on the current MessageLoop.
144 base::RunLoop().RunUntilIdle();
145 }
146
147 // Static.
DropPendingIO()148 void File::DropPendingIO() {
149 }
150
151 File::~File() = default;
152
platform_file() const153 base::PlatformFile File::platform_file() const {
154 return base_file_.GetPlatformFile();
155 }
156
157 // Runs on a worker thread.
DoRead(void * buffer,size_t buffer_len,size_t offset)158 int File::DoRead(void* buffer, size_t buffer_len, size_t offset) {
159 if (Read(const_cast<void*>(buffer), buffer_len, offset))
160 return static_cast<int>(buffer_len);
161
162 return net::ERR_CACHE_READ_FAILURE;
163 }
164
165 // Runs on a worker thread.
DoWrite(const void * buffer,size_t buffer_len,size_t offset)166 int File::DoWrite(const void* buffer, size_t buffer_len, size_t offset) {
167 if (Write(const_cast<void*>(buffer), buffer_len, offset))
168 return static_cast<int>(buffer_len);
169
170 return net::ERR_CACHE_WRITE_FAILURE;
171 }
172
173 // This method actually makes sure that the last reference to the file doesn't
174 // go away on the worker pool.
OnOperationComplete(FileIOCallback * callback,int result)175 void File::OnOperationComplete(FileIOCallback* callback, int result) {
176 callback->OnFileIOComplete(result);
177 }
178
179 } // namespace disk_cache
180