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
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_DOMAIN_RELIABILITY_CONTEXT_H_
#define COMPONENTS_DOMAIN_RELIABILITY_CONTEXT_H_
#include <stddef.h>
#include <deque>
#include <vector>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "components/domain_reliability/beacon.h"
#include "components/domain_reliability/config.h"
#include "components/domain_reliability/domain_reliability_export.h"
#include "components/domain_reliability/scheduler.h"
#include "components/domain_reliability/uploader.h"
class GURL;
namespace base {
class Value;
}
namespace domain_reliability {
class DomainReliabilityDispatcher;
class DomainReliabilityUploader;
class MockableTime;
// The per-domain context for the Domain Reliability client; includes the
// domain's config and beacon queue.
class DOMAIN_RELIABILITY_EXPORT DomainReliabilityContext {
public:
// Maximum upload depth to schedule an upload. If a beacon is based on a more
// deeply nested upload, it will be reported eventually, but will not itself
// trigger a new upload.
static const int kMaxUploadDepthToSchedule;
class DOMAIN_RELIABILITY_EXPORT Factory {
public:
virtual ~Factory();
virtual scoped_ptr<DomainReliabilityContext> CreateContextForConfig(
scoped_ptr<const DomainReliabilityConfig> config) = 0;
};
DomainReliabilityContext(
MockableTime* time,
const DomainReliabilityScheduler::Params& scheduler_params,
const std::string& upload_reporter_string,
const base::TimeTicks* last_network_change_time,
DomainReliabilityDispatcher* dispatcher,
DomainReliabilityUploader* uploader,
scoped_ptr<const DomainReliabilityConfig> config);
~DomainReliabilityContext();
// Notifies the context of a beacon on its domain(s); may or may not save the
// actual beacon to be uploaded, depending on the sample rates in the config,
// but will increment one of the request counters in any case.
void OnBeacon(scoped_ptr<DomainReliabilityBeacon> beacon);
// Called to clear browsing data, since beacons are like browsing history.
void ClearBeacons();
// Gets a Value containing data that can be formatted into a web page for
// debugging purposes.
scoped_ptr<base::Value> GetWebUIData() const;
// Gets the beacons queued for upload in this context. |*beacons_out| will be
// cleared and filled with pointers to the beacons; the pointers remain valid
// as long as no other requests are reported to the DomainReliabilityMonitor.
void GetQueuedBeaconsForTesting(
std::vector<const DomainReliabilityBeacon*>* beacons_out) const;
const DomainReliabilityConfig& config() const { return *config_.get(); }
// Maximum number of beacons queued per context; if more than this many are
// queued; the oldest beacons will be removed.
static const size_t kMaxQueuedBeacons;
private:
// Deque of beacons owned by this context. (Deleted after uploading.)
typedef std::deque<DomainReliabilityBeacon*> BeaconDeque;
void ScheduleUpload(base::TimeDelta min_delay, base::TimeDelta max_delay);
void StartUpload();
void OnUploadComplete(const DomainReliabilityUploader::UploadResult& result);
scoped_ptr<const base::Value> CreateReport(base::TimeTicks upload_time,
const GURL& collector_url,
int* max_beacon_depth_out) const;
// Remembers the current state of the context when an upload starts. Can be
// called multiple times in a row (without |CommitUpload|) if uploads fail
// and are retried.
void MarkUpload();
// Uses the state remembered by |MarkUpload| to remove successfully uploaded
// data but keep beacons and request counts added after the upload started.
void CommitUpload();
void RollbackUpload();
// Finds and removes the oldest beacon. DCHECKs if there is none. (Called
// when there are too many beacons queued.)
void RemoveOldestBeacon();
scoped_ptr<const DomainReliabilityConfig> config_;
MockableTime* time_;
const std::string& upload_reporter_string_;
DomainReliabilityScheduler scheduler_;
DomainReliabilityDispatcher* dispatcher_;
DomainReliabilityUploader* uploader_;
BeaconDeque beacons_;
size_t uploading_beacons_size_;
base::TimeTicks upload_time_;
base::TimeTicks last_upload_time_;
// The last network change time is not tracked per-context, so this is a
// pointer to that value in a wider (e.g. per-Monitor or unittest) scope.
const base::TimeTicks* last_network_change_time_;
base::WeakPtrFactory<DomainReliabilityContext> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(DomainReliabilityContext);
};
} // namespace domain_reliability
#endif // COMPONENTS_DOMAIN_RELIABILITY_CONTEXT_H_
|
