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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// 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_MONITOR_H_
#define COMPONENTS_DOMAIN_RELIABILITY_MONITOR_H_
#include <map>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/single_thread_task_runner.h"
#include "base/time/time.h"
#include "components/domain_reliability/beacon.h"
#include "components/domain_reliability/clear_mode.h"
#include "components/domain_reliability/config.h"
#include "components/domain_reliability/context.h"
#include "components/domain_reliability/context_manager.h"
#include "components/domain_reliability/dispatcher.h"
#include "components/domain_reliability/domain_reliability_export.h"
#include "components/domain_reliability/scheduler.h"
#include "components/domain_reliability/uploader.h"
#include "components/domain_reliability/util.h"
#include "net/base/load_timing_info.h"
#include "net/base/network_change_notifier.h"
#include "net/http/http_response_info.h"
#include "net/socket/connection_attempts.h"
#include "net/url_request/url_request_status.h"
namespace base {
class ThreadChecker;
class Value;
} // namespace base
namespace net {
class URLRequest;
class URLRequestContext;
class URLRequestContextGetter;
} // namespace net
namespace domain_reliability {
// The top-level object that measures requests and hands off the measurements
// to the proper |DomainReliabilityContext|.
class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
: public net::NetworkChangeNotifier::NetworkChangeObserver,
DomainReliabilityContext::Factory {
public:
// Creates a Monitor. |local_state_pref_service| must live on |pref_thread|
// (which should be the current thread); |network_thread| is the thread
// on which requests will actually be monitored and reported.
DomainReliabilityMonitor(
const std::string& upload_reporter_string,
const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
const scoped_refptr<base::SingleThreadTaskRunner>& network_thread);
// Same, but specifies a mock interface for time functions for testing.
DomainReliabilityMonitor(
const std::string& upload_reporter_string,
const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
const scoped_refptr<base::SingleThreadTaskRunner>& network_thread,
scoped_ptr<MockableTime> time);
// Must be called from the pref thread if |MoveToNetworkThread| was not
// called, or from the network thread if it was called.
~DomainReliabilityMonitor() override;
// Must be called before |InitURLRequestContext| on the same thread on which
// the Monitor was constructed. Moves (most of) the Monitor to the network
// thread passed in the constructor.
void MoveToNetworkThread();
// All public methods below this point must be called on the network thread
// after |MoveToNetworkThread| is called on the pref thread.
// Initializes the Monitor's URLRequestContextGetter.
//
// Must be called on the network thread, after |MoveToNetworkThread|.
void InitURLRequestContext(net::URLRequestContext* url_request_context);
// Same, but for unittests where the Getter is readily available.
void InitURLRequestContext(
const scoped_refptr<net::URLRequestContextGetter>&
url_request_context_getter);
// Populates the monitor with contexts that were configured at compile time.
void AddBakedInConfigs();
// Sets whether the uploader will discard uploads. Must be called after
// |InitURLRequestContext|.
void SetDiscardUploads(bool discard_uploads);
// Should be called when |request| is about to follow a redirect. Will
// examine and possibly log the redirect request. Must be called after
// |SetDiscardUploads|.
void OnBeforeRedirect(net::URLRequest* request);
// Should be called when |request| is complete. Will examine and possibly
// log the (final) request. |started| should be true if the request was
// actually started before it was terminated. Must be called after
// |SetDiscardUploads|.
void OnCompleted(net::URLRequest* request, bool started);
// net::NetworkChangeNotifier::NetworkChangeObserver implementation:
void OnNetworkChanged(
net::NetworkChangeNotifier::ConnectionType type) override;
// Called to remove browsing data. With CLEAR_BEACONS, leaves contexts in
// place but clears beacons (which betray browsing history); with
// CLEAR_CONTEXTS, removes all contexts (which can behave as cookies).
void ClearBrowsingData(DomainReliabilityClearMode mode);
// Gets a Value containing data that can be formatted into a web page for
// debugging purposes.
scoped_ptr<base::Value> GetWebUIData() const;
DomainReliabilityContext* AddContextForTesting(
scoped_ptr<const DomainReliabilityConfig> config);
size_t contexts_size_for_testing() const {
return context_manager_.contexts_size_for_testing();
}
// DomainReliabilityContext::Factory implementation:
scoped_ptr<DomainReliabilityContext> CreateContextForConfig(
scoped_ptr<const DomainReliabilityConfig> config) override;
private:
friend class DomainReliabilityMonitorTest;
// Allow the Service to call |MakeWeakPtr|.
friend class DomainReliabilityServiceImpl;
typedef std::map<std::string, DomainReliabilityContext*> ContextMap;
struct DOMAIN_RELIABILITY_EXPORT RequestInfo {
RequestInfo();
explicit RequestInfo(const net::URLRequest& request);
~RequestInfo();
static bool ShouldReportRequest(const RequestInfo& request);
GURL url;
net::URLRequestStatus status;
net::HttpResponseInfo response_info;
int load_flags;
net::LoadTimingInfo load_timing_info;
net::ConnectionAttempts connection_attempts;
bool is_upload;
};
void OnRequestLegComplete(const RequestInfo& info);
bool OnPrefThread() const {
return pref_task_runner_->BelongsToCurrentThread();
}
bool OnNetworkThread() const {
return network_task_runner_->BelongsToCurrentThread();
}
base::WeakPtr<DomainReliabilityMonitor> MakeWeakPtr();
scoped_ptr<MockableTime> time_;
base::TimeTicks last_network_change_time_;
const std::string upload_reporter_string_;
DomainReliabilityScheduler::Params scheduler_params_;
DomainReliabilityDispatcher dispatcher_;
scoped_ptr<DomainReliabilityUploader> uploader_;
DomainReliabilityContextManager context_manager_;
scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
bool moved_to_network_thread_;
bool discard_uploads_set_;
base::WeakPtrFactory<DomainReliabilityMonitor> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(DomainReliabilityMonitor);
};
} // namespace domain_reliability
#endif // COMPONENTS_DOMAIN_RELIABILITY_MONITOR_H_
|
