1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_CONTENT_CACHE_LOCAL_FD_H_
#define CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_CONTENT_CACHE_LOCAL_FD_H_
#include "base/files/file.h"
#include "base/files/file_error_or.h"
#include "base/files/file_path.h"
#include "base/functional/callback_forward.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "net/base/io_buffer.h"
namespace ash::file_system_provider {
using FileErrorOrFileAndBytesRead =
base::FileErrorOr<std::pair<std::unique_ptr<base::File>, int>>;
using FileErrorOrFile = base::FileErrorOr<std::unique_ptr<base::File>>;
using FileErrorOrBytesReadCallback =
base::OnceCallback<void(base::FileErrorOr<int>)>;
// A thin wrapper around a `base::File` that enables re-use of the FD. On top of
// this, it ensures files are properly closed on their blocking task runner even
// if the events come in interleaved (e.g. a `ReadFile` is still responding when
// a `CloseFile` is received, the `CloseFile` will happen only after the
// `ReadFile` returns).
class LocalFD {
public:
LocalFD(const base::FilePath& file_path,
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
LocalFD(const LocalFD&) = delete;
LocalFD& operator=(const LocalFD&) = delete;
~LocalFD();
// Write the bytes in `buffer` at `offset` for `length` into the underlying
// `file_` that was opened. If `file_` is `nullptr` one will be created with
// the appropriate base::File::Flags. In the event the file was previously
// only opened for read, the old FD will get closed and a new one will be
// opened for writing.
void WriteBytes(scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length,
base::OnceCallback<void(base::File::Error)> callback);
// Read the bytes in `buffer` at `offset` for `length` into the underlying
// `file_` that was opened. If `file_` is `nullptr` one will be created with
// the appropriate base::File::Flags.
void ReadBytes(scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length,
FileErrorOrBytesReadCallback callback);
// Attempts to close the open `file_`. The `close_closure` will be invoked
// when the file is actually closed, this may not be immediately due to
// operations that are still pending.
void Close(base::OnceClosure close_closure);
private:
void OnBytesWritten(base::OnceCallback<void(base::File::Error)> callback,
FileErrorOrFile error_or_file);
void OnBytesRead(FileErrorOrBytesReadCallback callback,
FileErrorOrFileAndBytesRead error_or_file_and_bytes_read);
// A `base::File` is move-only, so in the event the file hasn't received a
// `Close` call, move the `file` back into `file_`.
void CloseOrCacheFile(std::unique_ptr<base::File> file);
// Deletes the `file_` on the `blocking_task_runner_` (`base::File::~File`
// runs close on destruction).
void CloseFile();
// Given the async nature of reading from a file, a `Close` can be
// requested whilst an operation is still in-progress. To avoid losing the
// close file attempt and thus keeping the `file_` around forever, keep track
// of the close via `schedule_close_` and when `in_progress_operation_ =
// false`, then close the file on completion.
bool in_progress_operation_ = false;
// Invoked when the file is atually closed.
base::OnceClosure close_closure_;
// If a `ReadBytes` operation is started, the underlying `file_` is in
// read-only mode (i.e. `base::File::FLAG_READ`), in the event a `WriteBytes`
// is attempted the `file_` will need to be re-opened for write operations and
// this bool will be false.
bool read_only_ = true;
base::FilePath file_path_;
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
std::unique_ptr<base::File> file_;
base::WeakPtrFactory<LocalFD> weak_ptr_factory_{this};
};
} // namespace ash::file_system_provider
#endif // CHROME_BROWSER_ASH_FILE_SYSTEM_PROVIDER_CONTENT_CACHE_LOCAL_FD_H_
|
