Domain Reliability: More security review.

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 36 matching lines @@
 
   net::URLRequestContext* context_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 };
 
 }  // namespace
 
 namespace domain_reliability {
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
-    net::URLRequestContext* url_request_context)
+    net::URLRequestContext* url_request_context,
+    const std::string& upload_reporter_string)
     : time_(new ActualTime()),
       url_request_context_getter_(scoped_refptr<net::URLRequestContextGetter>(
           new TrivialURLRequestContextGetter(
               url_request_context,
               content::BrowserThread::GetMessageLoopProxyForThread(
                   content::BrowserThread::IO)))),
+      upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       uploader_(
           DomainReliabilityUploader::Create(url_request_context_getter_)) {
   DCHECK(OnIOThread());
 }
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
     net::URLRequestContext* url_request_context,
+    const std::string& upload_reporter_string,
     scoped_ptr<MockableTime> time)
     : time_(time.Pass()),
       url_request_context_getter_(scoped_refptr<net::URLRequestContextGetter>(
           new TrivialURLRequestContextGetter(
               url_request_context,
               content::BrowserThread::GetMessageLoopProxyForThread(
                   content::BrowserThread::IO)))),
+      upload_reporter_string_(upload_reporter_string),
       scheduler_params_(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       uploader_(
           DomainReliabilityUploader::Create(url_request_context_getter_)) {
   DCHECK(OnIOThread());
 }
 
 DomainReliabilityMonitor::~DomainReliabilityMonitor() {
   DCHECK(OnIOThread());
-  STLDeleteContainerPairSecondPointers(
-      contexts_.begin(), contexts_.end());
+  STLDeleteContainerPairSecondPointers(contexts_.begin(), contexts_.end());
 }
 
 void DomainReliabilityMonitor::AddBakedInConfigs() {
   base::Time now = base::Time::Now();
   for (size_t i = 0; kBakedInJsonConfigs[i]; ++i) {
     std::string json(kBakedInJsonConfigs[i]);
     scoped_ptr<const DomainReliabilityConfig> config =
         DomainReliabilityConfig::FromJSON(json);
     if (config && config->IsExpired(now)) {
       LOG(WARNING) << "Baked-in Domain Reliability config for "
                    << config->domain << " is expired.";
       continue;
     }
     AddContext(config.Pass());
   }
 }
 
 void DomainReliabilityMonitor::OnBeforeRedirect(net::URLRequest* request) {
   DCHECK(OnIOThread());
-  RequestInfo request_info(*request);
   // Record the redirect itself in addition to the final request.
-  OnRequestLegComplete(request_info);
+  OnRequestLegComplete(RequestInfo(*request));
 }
 
 void DomainReliabilityMonitor::OnCompleted(net::URLRequest* request,
                                            bool started) {
   DCHECK(OnIOThread());
   if (!started)
     return;
   RequestInfo request_info(*request);
   if (request_info.DefinitelyReachedNetwork()) {
     OnRequestLegComplete(request_info);
@@ skipping 29 matching lines @@
 
 bool DomainReliabilityMonitor::RequestInfo::DefinitelyReachedNetwork() const {
   return status.status() != net::URLRequestStatus::CANCELED && !was_cached;
 }
 
 DomainReliabilityContext* DomainReliabilityMonitor::AddContext(
     scoped_ptr<const DomainReliabilityConfig> config) {
   DCHECK(config);
   DCHECK(config->IsValid());
 
-  // Grab domain before we config.Pass().
+  // Grab a copy of the domain before transferring ownership of |config|.
   std::string domain = config->domain;
 
-  DomainReliabilityContext* context = new DomainReliabilityContext(
-      time_.get(),
-      scheduler_params_,
-      &dispatcher_,
-      uploader_.get(),
-      config.Pass());
+  DomainReliabilityContext* context =
+      new DomainReliabilityContext(time_.get(),
+                                   scheduler_params_,
+                                   upload_reporter_string_,
+                                   &dispatcher_,
+                                   uploader_.get(),
+                                   config.Pass());
 
   std::pair<ContextMap::iterator, bool> map_it =
       contexts_.insert(make_pair(domain, context));
   // Make sure the domain wasn't already in the map.
   DCHECK(map_it.second);
 
   return map_it.first->second;
 }
 
 void DomainReliabilityMonitor::OnRequestLegComplete(
@@ skipping 11 matching lines @@
   // to avoid infinite chains of uploads.
   if (request.is_upload)
     return;
 
   ContextMap::iterator it = contexts_.find(request.url.host());
   if (it == contexts_.end())
     return;
   DomainReliabilityContext* context = it->second;
 
   std::string beacon_status;
-  bool got_status = DomainReliabilityUtil::GetBeaconStatus(
+  bool got_status = GetDomainReliabilityBeaconStatus(
       request.status.error(),
       request.response_code,
       &beacon_status);
   if (!got_status)
     return;
 
   DomainReliabilityBeacon beacon;
   beacon.status = beacon_status;
   beacon.chrome_error = request.status.error();
   beacon.server_ip = request.socket_address.host();
   beacon.http_response_code = request.response_code;
   beacon.start_time = request.load_timing_info.request_start;
   beacon.elapsed = time_->NowTicks() - beacon.start_time;
-  context->AddBeacon(beacon, request.url);
+  context->OnBeacon(request.url, beacon);
 }
 
 }  // namespace domain_reliability