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
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/services/patch/public/cpp/patch.h"
#include <utility>
#include "base/files/file.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_refptr.h"
#include "base/task/sequenced_task_runner.h"
#include "components/services/patch/public/mojom/file_patcher.mojom.h"
#include "mojo/public/cpp/bindings/remote.h"
namespace patch {
namespace {
class PatchParams : public base::RefCounted<PatchParams> {
public:
PatchParams(mojo::PendingRemote<mojom::FilePatcher> file_patcher,
base::OnceCallback<void(int result)> callback)
: file_patcher_(std::move(file_patcher)),
callback_(std::move(callback)) {}
PatchParams(const PatchParams&) = delete;
PatchParams& operator=(const PatchParams&) = delete;
mojo::Remote<mojom::FilePatcher>& file_patcher() { return file_patcher_; }
base::OnceCallback<void(int)> TakeCallback() { return std::move(callback_); }
private:
friend class base::RefCounted<PatchParams>;
~PatchParams() = default;
// The mojo::Remote<FilePatcher> is stored so it does not get deleted before
// the callback runs.
mojo::Remote<mojom::FilePatcher> file_patcher_;
base::OnceCallback<void(int)> callback_;
};
void PatchDone(scoped_refptr<PatchParams> params, int result) {
params->file_patcher().reset();
base::OnceCallback<void(int)> cb = params->TakeCallback();
if (!cb.is_null())
std::move(cb).Run(result);
}
} // namespace
void PuffPatch(mojo::PendingRemote<mojom::FilePatcher> file_patcher,
base::File input_file,
base::File patch_file,
base::File output_file,
base::OnceCallback<void(int)> callback) {
// Use a context object to share callback.
scoped_refptr<PatchParams> patch_params = base::MakeRefCounted<PatchParams>(
std::move(file_patcher), std::move(callback));
patch_params->file_patcher().set_disconnect_handler(
base::BindOnce(&PatchDone, patch_params, /*result=*/-1));
patch_params->file_patcher()->PatchFilePuffPatch(
std::move(input_file), std::move(patch_file), std::move(output_file),
base::BindOnce(&PatchDone, patch_params));
}
void ZucchiniPatch(mojo::PendingRemote<mojom::FilePatcher> file_patcher,
base::File in,
base::File patch,
base::File out,
base::OnceCallback<void(zucchini::status::Code)> callback) {
mojo::Remote<mojom::FilePatcher> patcher(std::move(file_patcher));
auto* patcher_raw = patcher.get();
patcher_raw->PatchFileZucchini(
std::move(in), std::move(patch), std::move(out),
base::BindOnce([](mojo::Remote<mojom::FilePatcher> remote,
zucchini::status::Code result) { return result; },
std::move(patcher))
.Then(std::move(callback)));
}
} // namespace patch
|
