Domain Reliability: Add wildcard domain support.

components/domain_reliability/monitor.cc

 // 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.
 
 #include "components/domain_reliability/monitor.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 178 matching lines @@
   contexts_.clear();
 }
 
 void DomainReliabilityMonitor::OnRequestLegComplete(
     const RequestInfo& request) {
   int response_code;
   if (request.response_info.headers)
     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.
   // 3. The request is not supposed to send cookies (to avoid associating the
   //    request with any potentially unique data in the config).
   // 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 ||
       !GetDomainReliabilityBeaconStatus(
           error_code, response_code, &beacon_status)) {
     return;
   }
 
   DomainReliabilityBeacon beacon;
   beacon.status = beacon_status;
   beacon.chrome_error = error_code;
   if (!request.response_info.was_fetched_via_proxy)
     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>
 DomainReliabilityMonitor::MakeWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace domain_reliability