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
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/network/http_cache_data_counter.h"
#include <utility>
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "net/disk_cache/disk_cache.h"
#include "net/http/http_cache.h"
#include "net/url_request/url_request_context.h"
namespace network {
std::unique_ptr<HttpCacheDataCounter> HttpCacheDataCounter::CreateAndStart(
net::URLRequestContext* url_request_context,
base::Time start_time,
base::Time end_time,
HttpCacheDataCounterCallback callback) {
HttpCacheDataCounter* instance =
new HttpCacheDataCounter(start_time, end_time, std::move(callback));
net::HttpCache* http_cache =
url_request_context->http_transaction_factory()->GetCache();
if (!http_cache) {
// No cache, no space used. Posts a task, so it will run after the return.
instance->PostResult(false, 0);
} else {
auto get_backend_callback = base::BindOnce(
&HttpCacheDataCounter::GotBackend, instance->GetWeakPtr());
net::HttpCache::GetBackendResult result =
http_cache->GetBackend(std::move(get_backend_callback));
if (result.first != net::ERR_IO_PENDING) {
instance->GotBackend(result);
}
}
return base::WrapUnique(instance);
}
HttpCacheDataCounter::HttpCacheDataCounter(
base::Time start_time,
base::Time end_time,
HttpCacheDataCounterCallback callback)
: start_time_(start_time),
end_time_(end_time),
callback_(std::move(callback)) {}
HttpCacheDataCounter::~HttpCacheDataCounter() {}
void HttpCacheDataCounter::GotBackend(
std::pair<int, raw_ptr<disk_cache::Backend>> result) {
int error_code = result.first;
disk_cache::Backend* cache = result.second;
DCHECK_LE(error_code, 0);
bool is_upper_limit = false;
if (error_code != net::OK) {
PostResult(is_upper_limit, error_code);
return;
}
if (!cache) {
PostResult(is_upper_limit, 0);
return;
}
int64_t rv;
// Handle this here since some backends would DCHECK on this.
if (start_time_ > end_time_) {
PostResult(is_upper_limit, 0);
return;
}
if (start_time_.is_null() && end_time_.is_max()) {
rv = cache->CalculateSizeOfAllEntries(base::BindOnce(
&HttpCacheDataCounter::PostResult, GetWeakPtr(), is_upper_limit));
} else {
rv = cache->CalculateSizeOfEntriesBetween(
start_time_, end_time_,
base::BindOnce(&HttpCacheDataCounter::PostResult, GetWeakPtr(),
is_upper_limit));
if (rv == net::ERR_NOT_IMPLEMENTED) {
is_upper_limit = true;
rv = cache->CalculateSizeOfAllEntries(base::BindOnce(
&HttpCacheDataCounter::PostResult, GetWeakPtr(), is_upper_limit));
}
}
if (rv != net::ERR_IO_PENDING)
PostResult(is_upper_limit, rv);
}
void HttpCacheDataCounter::PostResult(bool is_upper_limit,
int64_t result_or_error) {
base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback_), this, is_upper_limit,
result_or_error));
}
} // namespace network
|
