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
|
// 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/download/internal/background_service/entry_utils.h"
#include <algorithm>
#include "components/download/internal/background_service/download_driver.h"
#include "components/download/internal/background_service/entry.h"
#include "components/download/public/background_service/download_metadata.h"
namespace download {
namespace util {
uint32_t GetNumberOfLiveEntriesForClient(DownloadClient client,
const std::vector<Entry*>& entries) {
uint32_t count = 0;
for (auto* entry : entries)
if (entry->client == client && entry->state != Entry::State::COMPLETE)
count++;
return count;
}
std::map<DownloadClient, std::vector<DownloadMetaData>>
MapEntriesToMetadataForClients(const std::set<DownloadClient>& clients,
const std::vector<Entry*>& entries,
DownloadDriver* driver) {
std::map<DownloadClient, std::vector<DownloadMetaData>> categorized;
for (auto* entry : entries) {
DownloadClient client = entry->client;
if (clients.find(client) == clients.end())
client = DownloadClient::INVALID;
categorized[client].push_back(BuildDownloadMetaData(entry, driver));
}
return categorized;
}
Criteria GetSchedulingCriteria(const Model::EntryList& entries,
int optimal_battery_percentage) {
Criteria criteria(optimal_battery_percentage);
// The scheduling criteria can only become less strict, from requiring battery
// charging to not requiring charging, from requiring unmetered network to
// any network. Optimal battery level can only decrease.
for (auto* const entry : entries) {
DCHECK(entry);
const SchedulingParams& scheduling_params = entry->scheduling_params;
switch (scheduling_params.battery_requirements) {
case SchedulingParams::BatteryRequirements::BATTERY_INSENSITIVE:
criteria.requires_battery_charging = false;
criteria.optimal_battery_percentage =
std::min(criteria.optimal_battery_percentage,
DeviceStatus::kBatteryPercentageAlwaysStart);
break;
case SchedulingParams::BatteryRequirements::BATTERY_SENSITIVE:
criteria.requires_battery_charging = false;
criteria.optimal_battery_percentage = std::min(
criteria.optimal_battery_percentage, optimal_battery_percentage);
break;
case SchedulingParams::BatteryRequirements::BATTERY_CHARGING:
break;
default:
NOTREACHED();
}
if (scheduling_params.network_requirements ==
SchedulingParams::NetworkRequirements::NONE) {
criteria.requires_unmetered_network = false;
}
}
return criteria;
}
bool EntryBetterThan(const Entry& lhs, const Entry& rhs) {
if (lhs.scheduling_params.priority != rhs.scheduling_params.priority)
return lhs.scheduling_params.priority > rhs.scheduling_params.priority;
if (lhs.scheduling_params.cancel_time != rhs.scheduling_params.cancel_time) {
return lhs.scheduling_params.cancel_time <
rhs.scheduling_params.cancel_time;
}
return lhs.create_time < rhs.create_time;
}
DownloadMetaData BuildDownloadMetaData(Entry* entry, DownloadDriver* driver) {
DCHECK(entry);
DownloadMetaData meta_data;
meta_data.guid = entry->guid;
meta_data.paused = entry->state == Entry::State::PAUSED;
if (entry->state == Entry::State::COMPLETE) {
meta_data.completion_info =
CompletionInfo(entry->target_file_path, entry->bytes_downloaded,
entry->url_chain, entry->response_headers);
meta_data.completion_info->custom_data = entry->custom_data;
// If the download is completed, the |current_size| needs to pull from entry
// since the history db record has been deleted.
meta_data.current_size = entry->bytes_downloaded;
return meta_data;
}
auto driver_entry = driver->Find(entry->guid);
if (driver_entry)
meta_data.current_size = driver_entry->bytes_downloaded;
return meta_data;
}
} // namespace util
} // namespace download
|
