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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_METRICS_RANGES_MANAGER_H_
#define BASE_METRICS_RANGES_MANAGER_H_
#include <unordered_set>
#include <vector>
#include "base/base_export.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/bucket_ranges.h"
#include "base/synchronization/lock.h"
namespace base {
// Manages BucketRanges and their lifetime. When registering a BucketRanges
// to a RangesManager instance, if an equivalent one already exists (one with
// the exact same ranges), the passed BucketRanges is deleted. This is useful to
// prevent duplicate instances of equivalent BucketRanges. Upon the destruction
// of a RangesManager instance, all BucketRanges managed by it are destroyed. A
// BucketRanges instance should not be registered to multiple RangesManagers.
class BASE_EXPORT RangesManager {
public:
RangesManager();
RangesManager(const RangesManager&) = delete;
RangesManager& operator=(const RangesManager&) = delete;
virtual ~RangesManager();
// Gets the canonical BucketRanges object corresponding to `ranges`. If one
// does not exist, then `ranges` will be registered with this object, which
// will take ownership of it. Returns a pointer to the canonical ranges
// object. If it's different than `ranges`, the caller is responsible for
// deleting `ranges`.
virtual const BucketRanges* GetOrRegisterCanonicalRanges(
const BucketRanges* ranges);
// Gets all registered BucketRanges. The order of returned BucketRanges is not
// guaranteed.
virtual std::vector<const BucketRanges*> GetBucketRanges() const;
// Some tests may instantiate temporary StatisticsRecorders, each having their
// own RangesManager. During the tests, ranges may get registered with a
// recorder that later gets released, which would release the ranges as well.
// Calling this method prevents this, as the tests may not expect them to be
// deleted.
void DoNotReleaseRangesOnDestroyForTesting();
protected:
// Used to get the hash of a BucketRanges, which is simply its checksum.
struct BucketRangesHash {
size_t operator()(const BucketRanges* a) const;
};
// Comparator for BucketRanges. See `BucketRanges::Equals()`.
struct BucketRangesEqual {
bool operator()(const BucketRanges* a, const BucketRanges* b) const;
};
// Type for a set of unique RangesBucket, with their hash and equivalence
// defined by `BucketRangesHash` and `BucketRangesEqual`.
typedef std::unordered_set<raw_ptr<const BucketRanges, CtnExperimental>,
BucketRangesHash,
BucketRangesEqual>
RangesMap;
// Removes all registered BucketRanges and destroys them. This is called in
// the destructor.
virtual void ReleaseBucketRanges();
virtual RangesMap& GetRanges();
virtual const RangesMap& GetRanges() const;
private:
// The set of unique BucketRanges registered to the RangesManager.
RangesMap ranges_;
// Whether or not to release the registered BucketRanges when this
// RangesManager is destroyed. See `DoNotReleaseRangesOnDestroyForTesting()`.
bool do_not_release_ranges_on_destroy_for_testing_ = false;
};
class BASE_EXPORT ThreadSafeRangesManager final : public RangesManager {
public:
ThreadSafeRangesManager();
ThreadSafeRangesManager(const RangesManager&) = delete;
ThreadSafeRangesManager& operator=(const ThreadSafeRangesManager&) = delete;
~ThreadSafeRangesManager() override;
// RangesManager:
const BucketRanges* GetOrRegisterCanonicalRanges(
const BucketRanges* ranges) override;
std::vector<const BucketRanges*> GetBucketRanges() const override;
protected:
// RangesManager:
void ReleaseBucketRanges() override;
RangesMap& GetRanges() override;
const RangesMap& GetRanges() const override;
private:
// Used to protect access to |ranges_|.
mutable base::Lock lock_;
};
} // namespace base
#endif // BASE_METRICS_RANGES_MANAGER_H_
|
