Add NetworkIsolationKey field to ReportingReport

This adds a NetworkIsolationKey field to ReportingReport, which
represents the report to be sent via Reporting API to some previously
configured endpoint.

This NetworkIsolationKey will eventually be filled in with the
NetworkIsolationKey of the request for which the report was generated.

For now this field is always empty, except in tests.

Bug: 993805
Change-Id: Ie957d4600007f4a46c4fc32b3381d55f518b1a42
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2137924
Commit-Queue: Lily Chen <chlily@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#758027}

net/reporting/reporting_browsing_data_remover_unittest.cc

@@ -41,9 +41,10 @@ class ReportingBrowsingDataRemoverTest : public ReportingTestBase {
     }
   }
 
+  // TODO(chlily): Take NIK.
   void AddReport(const GURL& url) {
-    cache()->AddReport(url, kUserAgent_, kGroup_, kType_,
-                       std::make_unique<base::DictionaryValue>(), 0,
+    cache()->AddReport(NetworkIsolationKey::Todo(), url, kUserAgent_, kGroup_,
+                       kType_, std::make_unique<base::DictionaryValue>(), 0,
                        tick_clock()->NowTicks(), 0);
   }
 

net/reporting/reporting_cache.h

@@ -57,7 +57,8 @@ class NET_EXPORT ReportingCache {
   //
   // All parameters correspond to the desired values for the relevant fields in
   // ReportingReport.
-  virtual void AddReport(const GURL& url,
+  virtual void AddReport(const NetworkIsolationKey& network_isolation_key,
+                         const GURL& url,
                          const std::string& user_agent,
                          const std::string& group_name,
                          const std::string& type,

net/reporting/reporting_cache_impl.cc

@@ -29,17 +29,19 @@ ReportingCacheImpl::~ReportingCacheImpl() {
   }
 }
 
-void ReportingCacheImpl::AddReport(const GURL& url,
-                                   const std::string& user_agent,
-                                   const std::string& group_name,
-                                   const std::string& type,
-                                   std::unique_ptr<const base::Value> body,
-                                   int depth,
-                                   base::TimeTicks queued,
-                                   int attempts) {
-  auto report = std::make_unique<ReportingReport>(url, user_agent, group_name,
-                                                  type, std::move(body), depth,
-                                                  queued, attempts);
+void ReportingCacheImpl::AddReport(
+    const NetworkIsolationKey& network_isolation_key,
+    const GURL& url,
+    const std::string& user_agent,
+    const std::string& group_name,
+    const std::string& type,
+    std::unique_ptr<const base::Value> body,
+    int depth,
+    base::TimeTicks queued,
+    int attempts) {
+  auto report = std::make_unique<ReportingReport>(
+      network_isolation_key, url, user_agent, group_name, type, std::move(body),
+      depth, queued, attempts);
 
   auto inserted = reports_.insert(std::move(report));
   DCHECK(inserted.second);
@@ -84,6 +86,9 @@ base::Value ReportingCacheImpl::GetReportsAsValue() const {
   std::vector<base::Value> report_list;
   for (const ReportingReport* report : sorted_reports) {
     base::Value report_dict(base::Value::Type::DICTIONARY);
+    report_dict.SetKey(
+        "network_isolation_key",
+        base::Value(report->network_isolation_key.ToDebugString()));
     report_dict.SetKey("url", base::Value(report->url.spec()));
     report_dict.SetKey("group", base::Value(report->group));
     report_dict.SetKey("type", base::Value(report->type));

net/reporting/reporting_cache_impl.h

@@ -38,7 +38,8 @@ class ReportingCacheImpl : public ReportingCache {
   ~ReportingCacheImpl() override;
 
   // ReportingCache implementation
-  void AddReport(const GURL& url,
+  void AddReport(const NetworkIsolationKey& network_isolation_key,
+                 const GURL& url,
                  const std::string& user_agent,
                  const std::string& group_name,
                  const std::string& type,

net/reporting/reporting_delivery_agent_unittest.cc

@@ -39,6 +39,7 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
     UsePolicy(policy);
   }
 
+  const NetworkIsolationKey kNik_ = NetworkIsolationKey::Todo();
   const GURL kUrl_ = GURL("https://origin/path");
   const GURL kSubdomainUrl_ = GURL("https://sub.origin/path");
   const url::Origin kOrigin_ = url::Origin::Create(GURL("https://origin/"));
@@ -48,7 +49,7 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
   const std::string kType_ = "type";
   const base::Time kExpires_ = base::Time::Now() + base::TimeDelta::FromDays(7);
   const ReportingEndpointGroupKey kGroupKey_ =
-      ReportingEndpointGroupKey(NetworkIsolationKey(), kOrigin_, kGroup_);
+      ReportingEndpointGroupKey(kNik_, kOrigin_, kGroup_);
 };
 
 TEST_F(ReportingDeliveryAgentTest, SuccessfulImmediateUpload) {
@@ -56,8 +57,8 @@ TEST_F(ReportingDeliveryAgentTest, SuccessfulImmediateUpload) {
   body.SetString("key", "value");
 
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_, body.CreateDeepCopy(),
-                     0, tick_clock()->NowTicks(), 0);
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
+                     body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
 
   // Upload is automatically started when cache is modified.
 
@@ -105,7 +106,7 @@ TEST_F(ReportingDeliveryAgentTest, SuccessfulImmediateSubdomainUpload) {
 
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_,
                                  OriginSubdomains::INCLUDE));
-  cache()->AddReport(kSubdomainUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kSubdomainUrl_, kUserAgent_, kGroup_, kType_,
                      body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
 
   // Upload is automatically started when cache is modified.
@@ -155,7 +156,7 @@ TEST_F(ReportingDeliveryAgentTest,
 
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_,
                                  OriginSubdomains::INCLUDE));
-  cache()->AddReport(kSubdomainUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kSubdomainUrl_, kUserAgent_, kGroup_, kType_,
                      body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
 
   // Upload is automatically started when cache is modified.
@@ -187,13 +188,13 @@ TEST_F(ReportingDeliveryAgentTest, SuccessfulDelayedUpload) {
 
   // Trigger and complete an upload to start the delivery timer.
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_, body.CreateDeepCopy(),
-                     0, tick_clock()->NowTicks(), 0);
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
+                     body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
   pending_uploads()[0]->Complete(ReportingUploader::Outcome::SUCCESS);
 
   // Add another report to upload after a delay.
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_, body.CreateDeepCopy(),
-                     0, tick_clock()->NowTicks(), 0);
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
+                     body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
 
   EXPECT_TRUE(delivery_timer()->IsRunning());
   delivery_timer()->Fire();
@@ -238,7 +239,7 @@ TEST_F(ReportingDeliveryAgentTest, SuccessfulDelayedUpload) {
 
 TEST_F(ReportingDeliveryAgentTest, FailedUpload) {
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -291,8 +292,8 @@ TEST_F(ReportingDeliveryAgentTest, DisallowedUpload) {
   body.SetString("key", "value");
 
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_, body.CreateDeepCopy(),
-                     0, tick_clock()->NowTicks(), 0);
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
+                     body.CreateDeepCopy(), 0, tick_clock()->NowTicks(), 0);
 
   tick_clock()->Advance(base::TimeDelta::FromMilliseconds(kAgeMillis));
 
@@ -327,7 +328,7 @@ TEST_F(ReportingDeliveryAgentTest, RemoveEndpointUpload) {
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
   ASSERT_TRUE(SetEndpointInCache(kOtherGroupKey, kEndpoint_, kExpires_));
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -356,7 +357,7 @@ TEST_F(ReportingDeliveryAgentTest, RemoveEndpointUpload) {
 
 TEST_F(ReportingDeliveryAgentTest, ConcurrentRemove) {
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -392,7 +393,7 @@ TEST_F(ReportingDeliveryAgentTest, ConcurrentRemoveDuringPermissionsCheck) {
   context()->test_delegate()->set_pause_permissions_check(true);
 
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -434,17 +435,17 @@ TEST_F(ReportingDeliveryAgentTest,
   ASSERT_TRUE(SetEndpointInCache(kDifferentGroupKey, kEndpoint_, kExpires_));
 
   // Trigger and complete an upload to start the delivery timer.
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   pending_uploads()[0]->Complete(ReportingUploader::Outcome::SUCCESS);
 
   // Now that the delivery timer is running, these reports won't be immediately
   // uploaded.
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
-  cache()->AddReport(kDifferentUrl, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kDifferentUrl, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   EXPECT_EQ(0u, pending_uploads().size());
@@ -467,7 +468,7 @@ TEST_F(ReportingDeliveryAgentTest,
 TEST_F(ReportingDeliveryAgentTest, SerializeUploadsToEndpoint) {
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -475,7 +476,7 @@ TEST_F(ReportingDeliveryAgentTest, SerializeUploadsToEndpoint) {
   delivery_timer()->Fire();
   EXPECT_EQ(1u, pending_uploads().size());
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -503,7 +504,7 @@ TEST_F(ReportingDeliveryAgentTest, SerializeUploadsToGroup) {
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kEndpoint_, kExpires_));
   ASSERT_TRUE(SetEndpointInCache(kGroupKey_, kDifferentEndpoint, kExpires_));
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -511,7 +512,7 @@ TEST_F(ReportingDeliveryAgentTest, SerializeUploadsToGroup) {
   delivery_timer()->Fire();
   EXPECT_EQ(1u, pending_uploads().size());
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -542,10 +543,10 @@ TEST_F(ReportingDeliveryAgentTest, ParallelizeUploadsAcrossGroups) {
   ASSERT_TRUE(
       SetEndpointInCache(kDifferentGroupKey, kDifferentEndpoint, kExpires_));
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
-  cache()->AddReport(kUrl_, kUserAgent_, kDifferentGroup, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kDifferentGroup, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 

net/reporting/reporting_endpoint_manager_unittest.cc

@@ -47,7 +47,8 @@ class TestReportingCache : public ReportingCache {
   }
 
   // Everything below is NOTREACHED.
-  void AddReport(const GURL& url,
+  void AddReport(const NetworkIsolationKey& network_isolation_key,
+                 const GURL& url,
                  const std::string& user_agent,
                  const std::string& group_name,
                  const std::string& type,

net/reporting/reporting_garbage_collector_unittest.cc

@@ -26,6 +26,7 @@ class ReportingGarbageCollectorTest : public ReportingTestBase {
     return reports.size();
   }
 
+  const NetworkIsolationKey kNik_;
   const GURL kUrl_ = GURL("https://origin/path");
   const std::string kUserAgent_ = "Mozilla/1.0";
   const std::string kGroup_ = "group";
@@ -41,7 +42,7 @@ TEST_F(ReportingGarbageCollectorTest, Created) {
 TEST_F(ReportingGarbageCollectorTest, Timer) {
   EXPECT_FALSE(garbage_collection_timer()->IsRunning());
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 
@@ -53,7 +54,7 @@ TEST_F(ReportingGarbageCollectorTest, Timer) {
 }
 
 TEST_F(ReportingGarbageCollectorTest, Report) {
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   garbage_collection_timer()->Fire();
@@ -62,7 +63,7 @@ TEST_F(ReportingGarbageCollectorTest, Report) {
 }
 
 TEST_F(ReportingGarbageCollectorTest, ExpiredReport) {
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   tick_clock()->Advance(2 * policy().max_report_age);
@@ -72,7 +73,7 @@ TEST_F(ReportingGarbageCollectorTest, ExpiredReport) {
 }
 
 TEST_F(ReportingGarbageCollectorTest, FailedReport) {
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
 

net/reporting/reporting_network_change_observer_unittest.cc

@@ -43,6 +43,7 @@ class ReportingNetworkChangeObserverTest : public ReportingTestBase {
     return reports.size();
   }
 
+  const NetworkIsolationKey kNik_;
   const GURL kUrl_ = GURL("https://origin/path");
   const url::Origin kOrigin_ = url::Origin::Create(kUrl_);
   const GURL kEndpoint_ = GURL("https://endpoint/");
@@ -59,7 +60,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearNothing) {
   new_policy.persist_clients_across_network_changes = true;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   SetEndpoint();
@@ -78,7 +79,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearReports) {
   new_policy.persist_clients_across_network_changes = true;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   SetEndpoint();
@@ -97,7 +98,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearClients) {
   new_policy.persist_clients_across_network_changes = false;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   SetEndpoint();
@@ -116,7 +117,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearReportsAndClients) {
   new_policy.persist_clients_across_network_changes = false;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kUrl_, kUserAgent_, kGroup_, kType_,
+  cache()->AddReport(kNik_, kUrl_, kUserAgent_, kGroup_, kType_,
                      std::make_unique<base::DictionaryValue>(), 0,
                      tick_clock()->NowTicks(), 0);
   SetEndpoint();

net/reporting/reporting_report.cc

@@ -24,15 +24,18 @@ void RecordReportOutcome(ReportingReport::Outcome outcome) {
 
 }  // namespace
 
-ReportingReport::ReportingReport(const GURL& url,
-                                 const std::string& user_agent,
-                                 const std::string& group,
-                                 const std::string& type,
-                                 std::unique_ptr<const base::Value> body,
-                                 int depth,
-                                 base::TimeTicks queued,
-                                 int attempts)
-    : url(url),
+ReportingReport::ReportingReport(
+    const NetworkIsolationKey& network_isolation_key,
+    const GURL& url,
+    const std::string& user_agent,
+    const std::string& group,
+    const std::string& type,
+    std::unique_ptr<const base::Value> body,
+    int depth,
+    base::TimeTicks queued,
+    int attempts)
+    : network_isolation_key(network_isolation_key),
+      url(url),
       user_agent(user_agent),
       group(group),
       type(type),

net/reporting/reporting_report.h

@@ -11,6 +11,7 @@
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
+#include "net/base/network_isolation_key.h"
 #include "url/gurl.h"
 
 namespace base {
@@ -51,7 +52,8 @@ struct NET_EXPORT ReportingReport {
   };
 
   // TODO(chlily): Remove |attempts| argument as it is (almost?) always 0.
-  ReportingReport(const GURL& url,
+  ReportingReport(const NetworkIsolationKey& network_isolation_key,
+                  const GURL& url,
                   const std::string& user_agent,
                   const std::string& group,
                   const std::string& type,
@@ -69,6 +71,10 @@ struct NET_EXPORT ReportingReport {
   // Whether the report is part of an ongoing delivery attempt.
   bool IsUploadPending() const;
 
+  // The NIK of the request that triggered this report. (Not included in the
+  // delivered report.)
+  NetworkIsolationKey network_isolation_key;
+
   // The URL of the document that triggered the report. (Included in the
   // delivered report.)
   GURL url;

net/reporting/reporting_service.cc

@@ -71,10 +71,12 @@ class ReportingServiceImpl : public ReportingService {
 
     // base::Unretained is safe because the callback is stored in
     // |task_backlog_| which will not outlive |this|.
-    DoOrBacklogTask(base::BindOnce(&ReportingServiceImpl::DoQueueReport,
-                                   base::Unretained(this),
-                                   std::move(sanitized_url), user_agent, group,
-                                   type, std::move(body), depth, queued_ticks));
+    // TODO(chlily): Get NetworkIsolationKey from caller.
+    NetworkIsolationKey network_isolation_key = NetworkIsolationKey::Todo();
+    DoOrBacklogTask(base::BindOnce(
+        &ReportingServiceImpl::DoQueueReport, base::Unretained(this),
+        network_isolation_key, std::move(sanitized_url), user_agent, group,
+        type, std::move(body), depth, queued_ticks));
   }
 
   void ProcessHeader(const GURL& url,
@@ -149,7 +151,8 @@ class ReportingServiceImpl : public ReportingService {
     std::move(task).Run();
   }
 
-  void DoQueueReport(GURL sanitized_url,
+  void DoQueueReport(const NetworkIsolationKey& network_isolation_key,
+                     GURL sanitized_url,
                      const std::string& user_agent,
                      const std::string& group,
                      const std::string& type,
@@ -157,9 +160,9 @@ class ReportingServiceImpl : public ReportingService {
                      int depth,
                      base::TimeTicks queued_ticks) {
     DCHECK(initialized_);
-    context_->cache()->AddReport(sanitized_url, user_agent, group, type,
-                                 std::move(body), depth, queued_ticks,
-                                 0 /* attempts */);
+    context_->cache()->AddReport(network_isolation_key, sanitized_url,
+                                 user_agent, group, type, std::move(body),
+                                 depth, queued_ticks, 0 /* attempts */);
   }
 
   void DoProcessHeader(const NetworkIsolationKey& network_isolation_key,