Reporting: Wrap existing classes in context.

net/reporting/reporting_delivery_agent.cc

 // Copyright 2017 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 "net/reporting/reporting_delivery_agent.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 32 matching lines @@
 
   std::string reports_json = "";
   bool json_written = base::JSONWriter::Write(reports_value, &reports_json);
   DCHECK(json_written);
 
   return reports_json;
 }
 
 }  // namespace
 
-ReportingDeliveryAgent::ReportingDeliveryAgent(
-    base::TickClock* clock,
-    ReportingCache* cache,
-    ReportingUploader* uploader,
-    const BackoffEntry::Policy* endpoint_backoff_policy)
-    : clock_(clock),
-      cache_(cache),
-      uploader_(uploader),
-      endpoint_manager_(clock, cache, endpoint_backoff_policy),
-      weak_factory_(this) {}
+ReportingDeliveryAgent::ReportingDeliveryAgent(ReportingContext* context)
+    : context_(context), weak_factory_(this) {}
 ReportingDeliveryAgent::~ReportingDeliveryAgent() {}
 
 class ReportingDeliveryAgent::Delivery {
  public:
   Delivery(const GURL& endpoint,
            const std::vector<const ReportingReport*>& reports)
       : endpoint(endpoint), reports(reports) {}
 
   ~Delivery() {}
 
   const GURL endpoint;
   const std::vector<const ReportingReport*> reports;
 };
 
 void ReportingDeliveryAgent::SendReports() {
   std::vector<const ReportingReport*> reports;
-  cache_->GetReports(&reports);
+  cache()->GetReports(&reports);
 
   // Sort reports into (origin, group) buckets.
   std::map<OriginGroup, std::vector<const ReportingReport*>>
       origin_group_reports;
   for (const ReportingReport* report : reports) {
     OriginGroup origin_group(url::Origin(report->url), report->group);
     origin_group_reports[origin_group].push_back(report);
   }
 
   // Find endpoint for each (origin, group) bucket and sort reports into
   // endpoint buckets. Don't allow concurrent deliveries to the same (origin,
   // group) bucket.
   std::map<GURL, std::vector<const ReportingReport*>> endpoint_reports;
   for (auto& it : origin_group_reports) {
     const OriginGroup& origin_group = it.first;
 
     if (base::ContainsKey(pending_origin_groups_, origin_group))
       continue;
 
     GURL endpoint_url;
-    if (!endpoint_manager_.FindEndpointForOriginAndGroup(
+    if (!endpoint_manager()->FindEndpointForOriginAndGroup(
             origin_group.first, origin_group.second, &endpoint_url)) {
       continue;
     }
 
     endpoint_reports[endpoint_url].insert(endpoint_reports[endpoint_url].end(),
                                           it.second.begin(), it.second.end());
     pending_origin_groups_.insert(origin_group);
   }
 
   // Start a delivery to each endpoint.
   for (auto& it : endpoint_reports) {
     const GURL& endpoint = it.first;
     const std::vector<const ReportingReport*>& reports = it.second;
 
-    endpoint_manager_.SetEndpointPending(endpoint);
-    cache_->SetReportsPending(reports);
+    endpoint_manager()->SetEndpointPending(endpoint);
+    cache()->SetReportsPending(reports);
 
-    uploader_->StartUpload(
-        endpoint, SerializeReports(reports, clock_->NowTicks()),
+    uploader()->StartUpload(
+        endpoint, SerializeReports(reports, tick_clock()->NowTicks()),
         base::Bind(&ReportingDeliveryAgent::OnUploadComplete,
                    weak_factory_.GetWeakPtr(),
                    base::MakeUnique<Delivery>(endpoint, reports)));
   }
 }
 
 void ReportingDeliveryAgent::OnUploadComplete(
     const std::unique_ptr<Delivery>& delivery,
     ReportingUploader::Outcome outcome) {
   if (outcome == ReportingUploader::Outcome::SUCCESS) {
-    cache_->RemoveReports(delivery->reports);
-    endpoint_manager_.InformOfEndpointRequest(delivery->endpoint, true);
+    cache()->RemoveReports(delivery->reports);
+    endpoint_manager()->InformOfEndpointRequest(delivery->endpoint, true);
   } else {
-    cache_->IncrementReportsAttempts(delivery->reports);
-    endpoint_manager_.InformOfEndpointRequest(delivery->endpoint, false);
+    cache()->IncrementReportsAttempts(delivery->reports);
+    endpoint_manager()->InformOfEndpointRequest(delivery->endpoint, false);
   }
 
   if (outcome == ReportingUploader::Outcome::REMOVE_ENDPOINT)
-    cache_->RemoveClientsForEndpoint(delivery->endpoint);
+    cache()->RemoveClientsForEndpoint(delivery->endpoint);
 
   for (const ReportingReport* report : delivery->reports) {
     pending_origin_groups_.erase(
         OriginGroup(url::Origin(report->url), report->group));
   }
 
-  cache_->ClearReportsPending(delivery->reports);
-  endpoint_manager_.ClearEndpointPending(delivery->endpoint);
+  endpoint_manager()->ClearEndpointPending(delivery->endpoint);
+  cache()->ClearReportsPending(delivery->reports);
 }
 
 }  // namespace net