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
133
134
135
136
137
138
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "storage/browser/blob/shareable_file_reference.h"
#include <map>
#include <utility>
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/sequence_checker.h"
#include "base/task/task_runner.h"
namespace storage {
namespace {
// A shareable file map with enforcement of sequence checker.
class ShareableFileMap {
public:
using FileMap = std::map<base::FilePath,
raw_ptr<ShareableFileReference, CtnExperimental>>;
using iterator = FileMap::iterator;
using key_type = FileMap::key_type;
using value_type = FileMap::value_type;
ShareableFileMap() = default;
ShareableFileMap(const ShareableFileMap&) = delete;
ShareableFileMap& operator=(const ShareableFileMap&) = delete;
~ShareableFileMap() = default;
iterator Find(key_type key) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return file_map_.find(key);
}
iterator End() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return file_map_.end();
}
std::pair<iterator, bool> Insert(value_type value) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return file_map_.insert(value);
}
void Erase(key_type key) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
file_map_.erase(key);
}
#if DCHECK_IS_ON()
void AssertCalledOnValidSequence() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
#endif // DCHECK_IS_ON()
private:
FileMap file_map_;
SEQUENCE_CHECKER(sequence_checker_);
};
base::LazyInstance<ShareableFileMap>::DestructorAtExit g_file_map =
LAZY_INSTANCE_INITIALIZER;
} // namespace
// static
scoped_refptr<ShareableFileReference> ShareableFileReference::Get(
const base::FilePath& path) {
auto found = g_file_map.Get().Find(path);
ShareableFileReference* reference =
(found == g_file_map.Get().End()) ? nullptr : found->second;
return scoped_refptr<ShareableFileReference>(reference);
}
// static
scoped_refptr<ShareableFileReference> ShareableFileReference::GetOrCreate(
const base::FilePath& path,
FinalReleasePolicy policy,
base::TaskRunner* file_task_runner) {
return GetOrCreate(
ScopedFile(path, static_cast<ScopedFile::ScopeOutPolicy>(policy),
file_task_runner));
}
// static
scoped_refptr<ShareableFileReference> ShareableFileReference::GetOrCreate(
ScopedFile scoped_file) {
if (scoped_file.path().empty())
return scoped_refptr<ShareableFileReference>();
auto result = g_file_map.Get().Insert(
ShareableFileMap::value_type(scoped_file.path(), nullptr));
DVLOG(1) << "ShareableFileReference::GetOrCreate("
<< scoped_file.path().value() << ", "
<< (scoped_file.policy() == ScopedFile::DELETE_ON_SCOPE_OUT
? "DELETE_ON_SCOPE_OUT"
: "DONT_DELETE_ON_SCOPE_OUT")
<< "): " << (result.second ? "Creation." : "New Reference.");
if (result.second == false) {
scoped_file.Release();
return scoped_refptr<ShareableFileReference>(result.first->second);
}
// Wasn't in the map, create a new reference and store the pointer.
scoped_refptr<ShareableFileReference> reference(
new ShareableFileReference(std::move(scoped_file)));
result.first->second = reference.get();
return reference;
}
void ShareableFileReference::AddFinalReleaseCallback(
FinalReleaseCallback callback) {
#if DCHECK_IS_ON()
g_file_map.Get().AssertCalledOnValidSequence();
#endif // DCHECK_IS_ON()
scoped_file_.AddScopeOutCallback(std::move(callback), nullptr);
}
ShareableFileReference::ShareableFileReference(ScopedFile scoped_file)
: scoped_file_(std::move(scoped_file)) {
DCHECK(g_file_map.Get().Find(path())->second == nullptr);
}
ShareableFileReference::~ShareableFileReference() {
DCHECK(g_file_map.Get().Find(path())->second == this);
g_file_map.Get().Erase(path());
}
} // namespace storage
|
