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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/host/file_transfer/buffered_file_writer.h"
#include "base/functional/bind.h"
#include <utility>
namespace remoting {
BufferedFileWriter::BufferedFileWriter(
std::unique_ptr<FileOperations::Writer> file_writer,
base::OnceClosure on_complete,
base::OnceCallback<void(protocol::FileTransfer_Error)> on_error)
: writer_(std::move(file_writer)),
on_complete_(std::move(on_complete)),
on_error_(std::move(on_error)) {
DCHECK(writer_);
DCHECK(writer_->state() == FileOperations::kCreated);
}
BufferedFileWriter::~BufferedFileWriter() = default;
void BufferedFileWriter::Start(const base::FilePath& filename) {
DCHECK_EQ(kNotStarted, state_);
SetState(kWorking);
// Unretained is sound because no Writer callbacks will be invoked after the
// Writer is destroyed.
writer_->Open(filename, base::BindOnce(&BufferedFileWriter::OnOperationResult,
base::Unretained(this)));
}
void BufferedFileWriter::Write(std::vector<std::uint8_t> data) {
if (state_ == kFailed) {
return;
}
DCHECK(state_ == kWorking || state_ == kWaiting);
chunks_.push(std::move(data));
if (state_ == kWaiting) {
SetState(kWorking);
WriteNextChunk();
}
}
void BufferedFileWriter::Close() {
if (state_ == kFailed) {
return;
}
DCHECK(state_ == kWorking || state_ == kWaiting);
State old_state = state_;
SetState(kClosing);
if (old_state != kWorking) {
DoClose();
}
}
void BufferedFileWriter::WriteNextChunk() {
DCHECK(!chunks_.empty());
DCHECK(state_ == kWorking || state_ == kClosing);
std::vector<std::uint8_t> data = std::move(chunks_.front());
chunks_.pop();
writer_->WriteChunk(std::move(data),
base::BindOnce(&BufferedFileWriter::OnOperationResult,
base::Unretained(this)));
}
// Handles the result from both Open and WriteChunk. For the former, it is
// called by OnWriteFileResult after setting writer_.
void BufferedFileWriter::OnOperationResult(
FileOperations::Writer::Result result) {
if (!result) {
SetState(kFailed);
std::move(on_error_).Run(std::move(result.error()));
return;
}
if (!chunks_.empty()) {
WriteNextChunk();
} else if (state_ == kClosing) {
DoClose();
} else {
SetState(kWaiting);
}
}
void BufferedFileWriter::DoClose() {
DCHECK(chunks_.empty());
DCHECK_EQ(kClosing, state_);
writer_->Close(base::BindOnce(&BufferedFileWriter::OnCloseResult,
base::Unretained(this)));
}
void BufferedFileWriter::OnCloseResult(FileOperations::Writer::Result result) {
if (!result) {
SetState(kFailed);
std::move(on_error_).Run(std::move(result.error()));
return;
}
SetState(kClosed);
std::move(on_complete_).Run();
}
void BufferedFileWriter::SetState(BufferedFileWriter::State state) {
switch (state) {
case kNotStarted:
// This is the initial state, but should never be reached again.
NOTREACHED();
case kWorking:
DCHECK(state_ == kNotStarted || state_ == kWaiting);
break;
case kWaiting:
DCHECK(state_ == kWorking);
break;
case kClosing:
DCHECK(state_ == kWorking || state_ == kWaiting);
break;
case kClosed:
DCHECK(state_ == kClosing);
break;
case kFailed:
// Any state can change to kFailed.
break;
}
state_ = state;
}
} // namespace remoting
|
