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
|
// Copyright 2019 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/optimization_guide/core/store_update_data.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "components/optimization_guide/core/optimization_guide_features.h"
#include "components/optimization_guide/core/optimization_guide_store.h"
#include "components/optimization_guide/proto/hint_cache.pb.h"
#include "components/optimization_guide/proto/hints.pb.h"
#include "components/optimization_guide/proto/models.pb.h"
namespace optimization_guide {
// static
std::unique_ptr<StoreUpdateData>
StoreUpdateData::CreateComponentStoreUpdateData(
const base::Version& component_version) {
return base::WrapUnique<StoreUpdateData>(
new StoreUpdateData(std::optional<base::Version>(component_version),
/*fetch_update_time=*/std::nullopt,
/*expiry_time=*/std::nullopt));
}
// static
std::unique_ptr<StoreUpdateData> StoreUpdateData::CreateFetchedStoreUpdateData(
base::Time fetch_update_time) {
return base::WrapUnique<StoreUpdateData>(new StoreUpdateData(
/*component_version=*/std::nullopt, fetch_update_time,
/*expiry_time=*/std::nullopt));
}
StoreUpdateData::StoreUpdateData(std::optional<base::Version> component_version,
std::optional<base::Time> fetch_update_time,
std::optional<base::Time> expiry_time)
: component_version_(component_version),
update_time_(fetch_update_time),
expiry_time_(expiry_time),
entries_to_save_(std::make_unique<EntryVector>()) {
DCHECK_NE(!component_version_, !update_time_);
if (component_version_.has_value()) {
entry_key_prefix_ = OptimizationGuideStore::GetComponentHintEntryKeyPrefix(
*component_version_);
// Add a component metadata entry for the component's version.
proto::StoreEntry metadata_component_entry;
metadata_component_entry.set_entry_type(static_cast<proto::StoreEntryType>(
OptimizationGuideStore::StoreEntryType::kMetadata));
metadata_component_entry.set_version(component_version_->GetString());
entries_to_save_->emplace_back(
OptimizationGuideStore::GetMetadataTypeEntryKey(
OptimizationGuideStore::MetadataType::kComponent),
std::move(metadata_component_entry));
} else if (update_time_.has_value()) {
entry_key_prefix_ = OptimizationGuideStore::GetFetchedHintEntryKeyPrefix();
proto::StoreEntry metadata_fetched_entry;
metadata_fetched_entry.set_entry_type(static_cast<proto::StoreEntryType>(
OptimizationGuideStore::StoreEntryType::kMetadata));
metadata_fetched_entry.set_update_time_secs(
update_time_->ToDeltaSinceWindowsEpoch().InSeconds());
entries_to_save_->emplace_back(
OptimizationGuideStore::GetMetadataTypeEntryKey(
OptimizationGuideStore::MetadataType::kFetched),
std::move(metadata_fetched_entry));
} else {
NOTREACHED();
}
// |this| may be modified on another thread after construction but all
// future modifications, from that call forward, must be made on the same
// thread.
DETACH_FROM_SEQUENCE(sequence_checker_);
}
StoreUpdateData::~StoreUpdateData() = default;
void StoreUpdateData::MoveHintIntoUpdateData(proto::Hint&& hint) {
// All future modifications must be made by the same thread. Note, |this| may
// have been constructed on another thread.
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!entry_key_prefix_.empty());
// To avoid any unnecessary copying, the hint is moved into proto::StoreEntry.
OptimizationGuideStore::EntryKey hint_entry_key =
entry_key_prefix_ + hint.key();
proto::StoreEntry entry_proto;
if (component_version()) {
entry_proto.set_entry_type(static_cast<proto::StoreEntryType>(
OptimizationGuideStore::StoreEntryType::kComponentHint));
} else if (update_time()) {
base::TimeDelta expiry_duration;
if (hint.has_max_cache_duration()) {
expiry_duration = base::Seconds(hint.max_cache_duration().seconds());
} else {
expiry_duration = features::StoredFetchedHintsFreshnessDuration();
}
entry_proto.set_expiry_time_secs((base::Time::Now() + expiry_duration)
.ToDeltaSinceWindowsEpoch()
.InSeconds());
entry_proto.set_entry_type(static_cast<proto::StoreEntryType>(
OptimizationGuideStore::StoreEntryType::kFetchedHint));
}
entry_proto.set_allocated_hint(new proto::Hint(std::move(hint)));
entries_to_save_->emplace_back(std::move(hint_entry_key),
std::move(entry_proto));
}
std::unique_ptr<EntryVector> StoreUpdateData::TakeUpdateEntries() {
// TakeUpdateEntries is not be sequence checked as it only gives up ownership
// of the entries_to_save_ and does not modify any state.
DCHECK(entries_to_save_);
return std::move(entries_to_save_);
}
} // namespace optimization_guide
|
