scheduler_params_(
DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
dispatcher_(time_.get()),
- was_cleared_(false),
- cleared_mode_(MAX_CLEAR_MODE),
weak_factory_(this) {}
DomainReliabilityMonitor::DomainReliabilityMonitor(
scheduler_params_(
DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
dispatcher_(time_.get()),
- was_cleared_(false),
- cleared_mode_(MAX_CLEAR_MODE),
weak_factory_(this) {}
DomainReliabilityMonitor::~DomainReliabilityMonitor() {
DomainReliabilityClearMode mode) {
DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
- was_cleared_ = true;
- cleared_mode_ = mode;
-
switch (mode) {
case CLEAR_BEACONS: {
ContextMap::const_iterator it;
}
}
+scoped_ptr<base::Value> DomainReliabilityMonitor::GetWebUIData() const {
+ base::ListValue* contexts_value = new base::ListValue();
+ for (ContextMap::const_iterator it = contexts_.begin();
+ it != contexts_.end();
+ ++it) {
+ contexts_value->Append(it->second->GetWebUIData().release());
+ }
+
+ base::DictionaryValue* data_value = new base::DictionaryValue();
+ data_value->Set("contexts", contexts_value);
+
+ return scoped_ptr<base::Value>(data_value);
+}
+
DomainReliabilityContext* DomainReliabilityMonitor::AddContextForTesting(
scoped_ptr<const DomainReliabilityConfig> config) {
DCHECK(thread_checker_ && thread_checker_->CalledOnValidThread());
response_code = request.response_info.headers->response_code();
else
response_code = -1;
- ContextMap::iterator context_it;
std::string beacon_status;
int error_code = net::OK;
if (request.status.status() == net::URLRequestStatus::FAILED)
error_code = request.status.error();
+ DomainReliabilityContext* context = GetContextForHost(request.url.host());
+
// Ignore requests where:
// 1. There is no context for the request host.
// 2. The request did not access the network.
// 4. The request was itself a Domain Reliability upload (to avoid loops).
// 5. There is no defined beacon status for the error or HTTP response code
// (to avoid leaking network-local errors).
- if ((context_it = contexts_.find(request.url.host())) == contexts_.end() ||
+ if (!context ||
!request.AccessedNetwork() ||
(request.load_flags & net::LOAD_DO_NOT_SEND_COOKIES) ||
request.is_upload ||
beacon.server_ip = request.response_info.socket_address.host();
else
beacon.server_ip.clear();
+ beacon.protocol = GetDomainReliabilityProtocol(
+ request.response_info.connection_info,
+ request.response_info.ssl_info.is_valid());
beacon.http_response_code = response_code;
beacon.start_time = request.load_timing_info.request_start;
beacon.elapsed = time_->NowTicks() - beacon.start_time;
- context_it->second->OnBeacon(request.url, beacon);
+ context->OnBeacon(request.url, beacon);
+}
+
+// TODO(ttuttle): Keep a separate wildcard_contexts_ map to avoid having to
+// prepend '*.' to domains.
+DomainReliabilityContext* DomainReliabilityMonitor::GetContextForHost(
+ const std::string& host) const {
+ ContextMap::const_iterator context_it;
+
+ context_it = contexts_.find(host);
+ if (context_it != contexts_.end())
+ return context_it->second;
+
+ std::string host_with_asterisk = "*." + host;
+ context_it = contexts_.find(host_with_asterisk);
+ if (context_it != contexts_.end())
+ return context_it->second;
+
+ size_t dot_pos = host.find('.');
+ if (dot_pos == std::string::npos)
+ return NULL;
+
+ // TODO(ttuttle): Make sure parent is not in PSL before using.
+
+ std::string parent_with_asterisk = "*." + host.substr(dot_pos + 1);
+ context_it = contexts_.find(parent_with_asterisk);
+ if (context_it != contexts_.end())
+ return context_it->second;
+
+ return NULL;
}
base::WeakPtr<DomainReliabilityMonitor>