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
|
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/file_manager/delete_io_task.h"
#include <memory>
#include "base/files/file.h"
#include "base/functional/callback.h"
#include "base/task/sequenced_task_runner.h"
#include "chrome/browser/ash/file_manager/io_task_util.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "google_apis/common/task_util.h"
#include "storage/browser/file_system/file_system_context.h"
#include "storage/browser/file_system/file_system_operation_runner.h"
namespace file_manager {
namespace io_task {
DeleteIOTask::DeleteIOTask(
std::vector<storage::FileSystemURL> file_urls,
scoped_refptr<storage::FileSystemContext> file_system_context,
bool show_notification)
: IOTask(show_notification), file_system_context_(file_system_context) {
progress_.state = State::kQueued;
progress_.type = OperationType::kDelete;
progress_.bytes_transferred = 0;
progress_.total_bytes = file_urls.size();
for (const auto& url : file_urls) {
progress_.sources.emplace_back(url, std::nullopt);
}
}
DeleteIOTask::~DeleteIOTask() {
if (operation_id_) {
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(
[](scoped_refptr<storage::FileSystemContext> file_system_context,
storage::FileSystemOperationRunner::OperationID operation_id) {
file_system_context->operation_runner()->Cancel(
operation_id, base::DoNothing());
},
file_system_context_, *operation_id_));
}
}
void DeleteIOTask::Execute(IOTask::ProgressCallback progress_callback,
IOTask::CompleteCallback complete_callback) {
progress_callback_ = std::move(progress_callback);
complete_callback_ = std::move(complete_callback);
if (progress_.sources.size() == 0) {
Complete(State::kSuccess);
return;
}
progress_.state = State::kInProgress;
DeleteFile(0);
}
void DeleteIOTask::Cancel() {
progress_.state = State::kCancelled;
// Any inflight operation will be cancelled when the task is destroyed.
}
// Calls the completion callback for the task. |progress_| should not be
// accessed after calling this.
void DeleteIOTask::Complete(State state) {
progress_.state = state;
base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE,
base::BindOnce(std::move(complete_callback_), std::move(progress_)));
}
void DeleteIOTask::DeleteFile(size_t idx) {
DCHECK(idx < progress_.sources.size());
const storage::FileSystemURL file_url = progress_.sources[idx].url;
content::GetIOThreadTaskRunner({})->PostTaskAndReplyWithResult(
FROM_HERE,
base::BindOnce(&StartDeleteOnIOThread, file_system_context_, file_url,
google_apis::CreateRelayCallback(
base::BindOnce(&DeleteIOTask::OnDeleteComplete,
weak_ptr_factory_.GetWeakPtr(), idx))),
base::BindOnce(&DeleteIOTask::SetCurrentOperationID,
weak_ptr_factory_.GetWeakPtr()));
}
void DeleteIOTask::OnDeleteComplete(size_t idx, base::File::Error error) {
DCHECK(idx < progress_.sources.size());
operation_id_.reset();
progress_.sources[idx].error = error;
progress_.bytes_transferred += 1;
if (idx < progress_.sources.size() - 1) {
progress_callback_.Run(progress_);
DeleteFile(idx + 1);
} else {
for (const auto& source : progress_.sources) {
if (source.error != base::File::FILE_OK) {
Complete(State::kError);
return;
}
}
Complete(State::kSuccess);
}
}
void DeleteIOTask::SetCurrentOperationID(
storage::FileSystemOperationRunner::OperationID id) {
operation_id_.emplace(id);
}
} // namespace io_task
} // namespace file_manager
|
