BASELINE: Update Chromium to 108.0.5359.70

Change-Id: I77334ff232b819600f275bd3cfe41fbaa3619230
Reviewed-on: https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/445904
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

50 files changed, 620 insertions, 570 deletions

diff --git a/chromium/net/reporting/OWNERS b/chromium/net/reporting/OWNERS
index acbf93af41e..4392ef47220 100644
--- a/chromium/net/reporting/OWNERS
+++ b/chromium/net/reporting/OWNERS
@@ -1 +1 @@
-yhirano@chromium.org
+ricea@chromium.org
diff --git a/chromium/net/reporting/README.md b/chromium/net/reporting/README.md
index 7ad6beb8b92..34eea76936d 100644
--- a/chromium/net/reporting/README.md
+++ b/chromium/net/reporting/README.md
@@ -73,7 +73,7 @@ by non-browser embedders as well as by Chromium.
 
 * The `ReportingService` is set up in a `URLRequestContext` by passing a
   `ReportingPolicy` to the `URLRequestContextBuilder`. This creates a
-  `ReportingService` which is owned by the `URLRequestContextStorage`.
+  `ReportingService` which is owned by the `URLRequestContext`.
 
 * `Report-To:` headers are processed by an `HttpNetworkTransaction` when they
   are received, and passed on to the `ReportingService` to be added to the
@@ -107,7 +107,7 @@ by non-browser embedders as well as by Chromium.
 
     * It queues reports via the `NetworkContext` using a
       `blink::mojom::ReportingServiceProxy` (implemented [in
-      `//content/browser/net/`][2]), which can queue Intervention, Deprecation,
+      `//content/browser/network/`][2]), which can queue Intervention, Deprecation,
       CSP Violation, and Permissions Policy Violation reports.
 
 * The `ChromeNetworkDelegate` [in `//chrome/browser/net/`][3] checks permissions
@@ -169,6 +169,6 @@ To support both mechanisms simultaneously, we do the following:
   group.
 
 [1]: https://chromium.googlesource.com/chromium/src/+/HEAD/third_party/blink/renderer/core/frame/reporting_observer.h
-[2]: https://chromium.googlesource.com/chromium/src/+/HEAD/content/browser/net/reporting_service_proxy.cc
+[2]: https://chromium.googlesource.com/chromium/src/+/HEAD/content/browser/network/reporting_service_proxy.cc
 [3]: https://chromium.googlesource.com/chromium/src/+/HEAD/chrome/browser/net/chrome_network_delegate.h
 [4]: https://chromium.googlesource.com/chromium/src/+/HEAD/components/cronet/android/test/javatests/src/org/chromium/net/NetworkErrorLoggingTest.java
diff --git a/chromium/net/reporting/mock_persistent_reporting_store.cc b/chromium/net/reporting/mock_persistent_reporting_store.cc
index eed7ef31cf2..8a11e1d4f66 100644
--- a/chromium/net/reporting/mock_persistent_reporting_store.cc
+++ b/chromium/net/reporting/mock_persistent_reporting_store.cc
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -102,52 +102,59 @@ std::ostream& operator<<(std::ostream& out,
       return out << "FLUSH()";
     case MockPersistentReportingStore::Command::Type::ADD_REPORTING_ENDPOINT:
       return out << "ADD_REPORTING_ENDPOINT("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ", "
                  << "endpoint=" << cmd.url << ")";
     case MockPersistentReportingStore::Command::Type::
         UPDATE_REPORTING_ENDPOINT_DETAILS:
       return out << "UPDATE_REPORTING_ENDPOINT_DETAILS("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ", "
                  << "endpoint=" << cmd.url << ")";
     case MockPersistentReportingStore::Command::Type::DELETE_REPORTING_ENDPOINT:
       return out << "DELETE_REPORTING_ENDPOINT("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ", "
                  << "endpoint=" << cmd.url << ")";
     case MockPersistentReportingStore::Command::Type::
         ADD_REPORTING_ENDPOINT_GROUP:
       return out << "ADD_REPORTING_ENDPOINT_GROUP("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ")";
     case MockPersistentReportingStore::Command::Type::
         UPDATE_REPORTING_ENDPOINT_GROUP_ACCESS_TIME:
       return out << "UPDATE_REPORTING_ENDPOINT_GROUP_ACCESS_TIME("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ")";
     case MockPersistentReportingStore::Command::Type::
         UPDATE_REPORTING_ENDPOINT_GROUP_DETAILS:
       return out << "UPDATE_REPORTING_ENDPOINT_GROUP_DETAILS("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ")";
     case MockPersistentReportingStore::Command::Type::
         DELETE_REPORTING_ENDPOINT_GROUP:
       return out << "DELETE_REPORTING_ENDPOINT_GROUP("
-                 << "NIK="
-                 << cmd.group_key.network_isolation_key.ToDebugString() << ", "
+                 << "NAK="
+                 << cmd.group_key.network_anonymization_key.ToDebugString()
+                 << ", "
                  << "origin=" << cmd.group_key.origin << ", "
                  << "group=" << cmd.group_key.group_name << ")";
   }
diff --git a/chromium/net/reporting/mock_persistent_reporting_store.h b/chromium/net/reporting/mock_persistent_reporting_store.h
index 41e06ab5b1e..4642a56fe33 100644
--- a/chromium/net/reporting/mock_persistent_reporting_store.h
+++ b/chromium/net/reporting/mock_persistent_reporting_store.h
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "base/callback.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_endpoint.h"
 #include "url/origin.h"
diff --git a/chromium/net/reporting/mock_persistent_reporting_store_unittest.cc b/chromium/net/reporting/mock_persistent_reporting_store_unittest.cc
index bbf58ba90b7..99920c7134f 100644
--- a/chromium/net/reporting/mock_persistent_reporting_store_unittest.cc
+++ b/chromium/net/reporting/mock_persistent_reporting_store_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -9,7 +9,7 @@
 #include "base/location.h"
 #include "base/test/bind.h"
 #include "base/time/time.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_endpoint.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ -30,7 +30,7 @@ ReportingData GetReportingData() {
   const url::Origin kOrigin =
       url::Origin::Create(GURL("https://example.test/"));
   const char kGroupName[] = "groupname";
-  const ReportingEndpointGroupKey kGroupKey(NetworkIsolationKey(), kOrigin,
+  const ReportingEndpointGroupKey kGroupKey(NetworkAnonymizationKey(), kOrigin,
                                             kGroupName);
   const ReportingEndpoint kEndpoint(kGroupKey,
                                     {GURL("https://endpoint.test/reports")});
diff --git a/chromium/net/reporting/reporting_browsing_data_remover.cc b/chromium/net/reporting/reporting_browsing_data_remover.cc
index 58849576036..25037466318 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover.cc
+++ b/chromium/net/reporting/reporting_browsing_data_remover.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_browsing_data_remover.h b/chromium/net/reporting/reporting_browsing_data_remover.h
index 93ce6b27cf6..f1445d9e30b 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover.h
+++ b/chromium/net/reporting/reporting_browsing_data_remover.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc b/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
index 05832c2a1d5..5d96fb69785 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
+++ b/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -9,7 +9,7 @@
 
 #include "base/bind.h"
 #include "base/test/simple_test_tick_clock.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_report.h"
@@ -43,15 +43,15 @@ class ReportingBrowsingDataRemoverTest : public ReportingTestBase {
 
   // TODO(chlily): Take NIK.
   void AddReport(const GURL& url) {
-    cache()->AddReport(absl::nullopt, NetworkIsolationKey(), url, kUserAgent_,
-                       kGroup_, kType_, base::Value::Dict(), 0,
+    cache()->AddReport(absl::nullopt, NetworkAnonymizationKey(), url,
+                       kUserAgent_, kGroup_, kType_, base::Value::Dict(), 0,
                        tick_clock()->NowTicks(), 0);
   }
 
   // TODO(chlily): Take NIK.
   void SetEndpoint(const url::Origin& origin) {
     SetEndpointInCache(
-        ReportingEndpointGroupKey(NetworkIsolationKey(), origin, kGroup_),
+        ReportingEndpointGroupKey(NetworkAnonymizationKey(), origin, kGroup_),
         kEndpoint_, base::Time::Now() + base::Days(7));
   }
 
@@ -155,10 +155,10 @@ TEST_F(ReportingBrowsingDataRemoverTest, RemoveSomeClients) {
                      /* host= */ kUrl1_.host());
   EXPECT_EQ(2u, report_count());
   EXPECT_FALSE(FindEndpointInCache(
-      ReportingEndpointGroupKey(NetworkIsolationKey(), kOrigin1_, kGroup_),
+      ReportingEndpointGroupKey(NetworkAnonymizationKey(), kOrigin1_, kGroup_),
       kEndpoint_));
   EXPECT_TRUE(FindEndpointInCache(
-      ReportingEndpointGroupKey(NetworkIsolationKey(), kOrigin2_, kGroup_),
+      ReportingEndpointGroupKey(NetworkAnonymizationKey(), kOrigin2_, kGroup_),
       kEndpoint_));
 }
 
diff --git a/chromium/net/reporting/reporting_cache.cc b/chromium/net/reporting/reporting_cache.cc
index 8773122dab3..f28ec35593e 100644
--- a/chromium/net/reporting/reporting_cache.cc
+++ b/chromium/net/reporting/reporting_cache.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_cache.h b/chromium/net/reporting/reporting_cache.h
index ba4bf5e4c24..b9e7017c247 100644
--- a/chromium/net/reporting/reporting_cache.h
+++ b/chromium/net/reporting/reporting_cache.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -59,7 +59,7 @@ class NET_EXPORT ReportingCache {
 
   // Adds a report to the cache.
   //
-  // |reporting_source| and |network_isolation_key| will be used when the
+  // |reporting_source| and |network_anonymization_key| will be used when the
   // report is delivered, to determine which endpoints are eligible to receive
   // this report, and which other reports this report can be batched with.
   //
@@ -67,7 +67,7 @@ class NET_EXPORT ReportingCache {
   // fields in ReportingReport.
   virtual void AddReport(
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const GURL& url,
       const std::string& user_agent,
       const std::string& group_name,
@@ -166,7 +166,7 @@ class NET_EXPORT ReportingCache {
   // to match the new header. All values are assumed to be valid as they have
   // passed through the ReportingHeaderParser.
   virtual void OnParsedHeader(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       std::vector<ReportingEndpointGroup> parsed_header) = 0;
 
@@ -186,8 +186,9 @@ class NET_EXPORT ReportingCache {
 
   // Remove client for the given (NIK, origin) pair, if it exists in the cache.
   // All endpoint groups and endpoints for that client are also removed.
-  virtual void RemoveClient(const NetworkIsolationKey& network_isolation_key,
-                            const url::Origin& origin) = 0;
+  virtual void RemoveClient(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const url::Origin& origin) = 0;
 
   // Remove all clients for the given |origin|, if any exists in the cache.
   // All endpoint groups and endpoints for |origin| are also removed.
@@ -282,7 +283,7 @@ class NET_EXPORT ReportingCache {
 
   // Returns whether a client for the given (NIK, Origin) exists.
   virtual bool ClientExistsForTesting(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin) const = 0;
 
   // Returns number of endpoint groups.
diff --git a/chromium/net/reporting/reporting_cache_impl.cc b/chromium/net/reporting/reporting_cache_impl.cc
index c9765152f14..6efc2507cba 100644
--- a/chromium/net/reporting/reporting_cache_impl.cc
+++ b/chromium/net/reporting/reporting_cache_impl.cc
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -29,7 +29,7 @@ ReportingCacheImpl::~ReportingCacheImpl() = default;
 
 void ReportingCacheImpl::AddReport(
     const absl::optional<base::UnguessableToken>& reporting_source,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const GURL& url,
     const std::string& user_agent,
     const std::string& group_name,
@@ -50,9 +50,8 @@ void ReportingCacheImpl::AddReport(
   }
 
   auto report = std::make_unique<ReportingReport>(
-      reporting_source, network_isolation_key, url, user_agent, group_name,
-      type, std::make_unique<base::Value>(std::move(body)), depth, queued,
-      attempts);
+      reporting_source, network_anonymization_key, url, user_agent, group_name,
+      type, std::move(body), depth, queued, attempts);
 
   auto inserted = reports_.insert(std::move(report));
   DCHECK(inserted.second);
@@ -103,17 +102,15 @@ base::Value ReportingCacheImpl::GetReportsAsValue() const {
   base::Value::List report_list;
   for (const ReportingReport* report : sorted_reports) {
     base::Value::Dict report_dict;
-    report_dict.Set("network_isolation_key",
-                    report->network_isolation_key.ToDebugString());
+    report_dict.Set("network_anonymization_key",
+                    report->network_anonymization_key.ToDebugString());
     report_dict.Set("url", report->url.spec());
     report_dict.Set("group", report->group);
     report_dict.Set("type", report->type);
     report_dict.Set("depth", report->depth);
     report_dict.Set("queued", NetLog::TickCountToString(report->queued));
     report_dict.Set("attempts", report->attempts);
-    if (report->body) {
-      report_dict.Set("body", report->body->Clone());
-    }
+    report_dict.Set("body", report->body.Clone());
     switch (report->status) {
       case ReportingReport::Status::DOOMED:
         report_dict.Set("status", "doomed");
@@ -249,10 +246,8 @@ ReportingEndpoint::Statistics* ReportingCacheImpl::GetEndpointStats(
     if (document_endpoints_source_it == document_endpoints_.end())
       return nullptr;
     const auto document_endpoint_it =
-        base::ranges::find_if(document_endpoints_source_it->second,
-                              [&group_key](ReportingEndpoint endpoint) {
-                                return endpoint.group_key == group_key;
-                              });
+        base::ranges::find(document_endpoints_source_it->second, group_key,
+                           &ReportingEndpoint::group_key);
     // The endpoint may have been removed while the upload was in progress. In
     // that case, we no longer care about the stats for the removed endpoint.
     if (document_endpoint_it == document_endpoints_source_it->second.end())
@@ -369,12 +364,12 @@ bool ReportingCacheImpl::IsReportDoomedForTesting(
 }
 
 void ReportingCacheImpl::OnParsedHeader(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin,
     std::vector<ReportingEndpointGroup> parsed_header) {
   ConsistencyCheckClients();
 
-  Client new_client(network_isolation_key, origin);
+  Client new_client(network_anonymization_key, origin);
   base::Time now = clock().Now();
   new_client.last_used = now;
 
@@ -389,8 +384,8 @@ void ReportingCacheImpl::OnParsedHeader(
 
     // Consistency check: the new client should have the same NIK and origin as
     // all groups parsed from this header.
-    DCHECK(new_group.group_key.network_isolation_key ==
-           new_client.network_isolation_key);
+    DCHECK(new_group.group_key.network_anonymization_key ==
+           new_client.network_anonymization_key);
     DCHECK_EQ(new_group.group_key.origin, new_client.origin);
 
     for (const auto& parsed_endpoint_info : parsed_endpoint_group.endpoints) {
@@ -422,7 +417,7 @@ void ReportingCacheImpl::OnParsedHeader(
 
   // Remove endpoint groups that may have been configured for an existing client
   // for |origin|, but which are not specified in the current header.
-  RemoveEndpointGroupsForClientOtherThan(network_isolation_key, origin,
+  RemoveEndpointGroupsForClientOtherThan(network_anonymization_key, origin,
                                          new_client.endpoint_group_names);
 
   EnforcePerClientAndGlobalEndpointLimits(
@@ -481,10 +476,11 @@ std::set<url::Origin> ReportingCacheImpl::GetAllOrigins() const {
 }
 
 void ReportingCacheImpl::RemoveClient(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin) {
   ConsistencyCheckClients();
-  ClientMap::iterator client_it = FindClientIt(network_isolation_key, origin);
+  ClientMap::iterator client_it =
+      FindClientIt(network_anonymization_key, origin);
   if (client_it == clients_.end())
     return;
   RemoveClientInternal(client_it);
@@ -646,7 +642,8 @@ void ReportingCacheImpl::AddClientsLoadedFromStore(
     }
 
     if (!client ||
-        client->network_isolation_key != group_key.network_isolation_key ||
+        client->network_anonymization_key !=
+            group_key.network_anonymization_key ||
         client->origin != group_key.origin) {
       // Store the old client and start a new one.
       if (client) {
@@ -656,7 +653,7 @@ void ReportingCacheImpl::AddClientsLoadedFromStore(
       }
       DCHECK(FindClientIt(group_key) == clients_.end());
       client = absl::make_optional(
-          Client(group_key.network_isolation_key, group_key.origin));
+          Client(group_key.network_anonymization_key, group_key.origin));
     }
     DCHECK(client.has_value());
     client->endpoint_group_names.insert(group_key.group_name);
@@ -669,7 +666,7 @@ void ReportingCacheImpl::AddClientsLoadedFromStore(
   }
 
   if (client) {
-    DCHECK(FindClientIt(client->network_isolation_key, client->origin) ==
+    DCHECK(FindClientIt(client->network_anonymization_key, client->origin) ==
            clients_.end());
     ClientMap::iterator client_it = clients_.insert(
         std::make_pair(client->origin.host(), std::move(*client)));
@@ -720,7 +717,8 @@ ReportingCacheImpl::GetCandidateEndpointsForDelivery(
   // We need to clear out the |reporting_source| field to get a group key which
   // can be compared to any V0 endpoint groups.
   ReportingEndpointGroupKey v0_lookup_group_key(
-      group_key.network_isolation_key, group_key.origin, group_key.group_name);
+      group_key.network_anonymization_key, group_key.origin,
+      group_key.group_name);
 
   // Look for an exact origin match for |origin| and |group|.
   EndpointGroupMap::iterator group_it =
@@ -743,12 +741,12 @@ ReportingCacheImpl::GetCandidateEndpointsForDelivery(
          ++client_it) {
       // Client for a superdomain of |origin|
       const Client& client = client_it->second;
-      if (client.network_isolation_key !=
-          v0_lookup_group_key.network_isolation_key) {
+      if (client.network_anonymization_key !=
+          v0_lookup_group_key.network_anonymization_key) {
         continue;
       }
       ReportingEndpointGroupKey superdomain_lookup_group_key(
-          v0_lookup_group_key.network_isolation_key, client.origin,
+          v0_lookup_group_key.network_anonymization_key, client.origin,
           v0_lookup_group_key.group_name);
       group_it = FindEndpointGroupIt(superdomain_lookup_group_key);
 
@@ -833,13 +831,13 @@ bool ReportingCacheImpl::EndpointGroupExistsForTesting(
 }
 
 bool ReportingCacheImpl::ClientExistsForTesting(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin) const {
   ConsistencyCheckClients();
   for (const auto& domain_and_client : clients_) {
     const Client& client = domain_and_client.second;
     DCHECK_EQ(client.origin.host(), domain_and_client.first);
-    if (client.network_isolation_key == network_isolation_key &&
+    if (client.network_anonymization_key == network_anonymization_key &&
         client.origin == origin) {
       return true;
     }
@@ -867,8 +865,8 @@ void ReportingCacheImpl::SetV1EndpointForTesting(
   DCHECK(!reporting_source.is_empty());
   DCHECK(group_key.IsDocumentEndpoint());
   DCHECK_EQ(reporting_source, group_key.reporting_source.value());
-  DCHECK(group_key.network_isolation_key ==
-         isolation_info.network_isolation_key());
+  DCHECK(group_key.network_anonymization_key ==
+         isolation_info.network_anonymization_key());
 
   ReportingEndpoint::EndpointInfo info;
   info.url = url;
@@ -906,7 +904,7 @@ void ReportingCacheImpl::SetEndpointForTesting(
   ClientMap::iterator client_it = FindClientIt(group_key);
   // If the client doesn't yet exist, add it.
   if (client_it == clients_.end()) {
-    Client new_client(group_key.network_isolation_key, group_key.origin);
+    Client new_client(group_key.network_anonymization_key, group_key.origin);
     std::string domain = group_key.origin.host();
     client_it = clients_.insert(std::make_pair(domain, std::move(new_client)));
   }
@@ -958,9 +956,10 @@ IsolationInfo ReportingCacheImpl::GetIsolationInfoForEndpoint(
     const ReportingEndpoint& endpoint) const {
   // V0 endpoint groups do not support credentials.
   if (!endpoint.group_key.reporting_source.has_value()) {
-    return IsolationInfo::CreatePartial(
-        IsolationInfo::RequestType::kOther,
-        endpoint.group_key.network_isolation_key);
+    // TODO(crbug/1372769): Remove this and have a better way to get an correct
+    // IsolationInfo here.
+    return IsolationInfo::DoNotUseCreatePartialFromNak(
+        endpoint.group_key.network_anonymization_key);
   }
   const auto it =
       isolation_info_.find(endpoint.group_key.reporting_source.value());
@@ -969,9 +968,9 @@ IsolationInfo ReportingCacheImpl::GetIsolationInfoForEndpoint(
 }
 
 ReportingCacheImpl::Client::Client(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin)
-    : network_isolation_key(network_isolation_key), origin(origin) {}
+    : network_anonymization_key(network_anonymization_key), origin(origin) {}
 
 ReportingCacheImpl::Client::Client(const Client& other) = default;
 
@@ -1010,7 +1009,7 @@ void ReportingCacheImpl::ConsistencyCheckClients() const {
 
   size_t total_endpoint_count = 0;
   size_t total_endpoint_group_count = 0;
-  std::set<std::pair<NetworkIsolationKey, url::Origin>>
+  std::set<std::pair<NetworkAnonymizationKey, url::Origin>>
       nik_origin_pairs_in_cache;
 
   for (const auto& domain_and_client : clients_) {
@@ -1020,7 +1019,7 @@ void ReportingCacheImpl::ConsistencyCheckClients() const {
     total_endpoint_group_count += ConsistencyCheckClient(domain, client);
 
     auto inserted = nik_origin_pairs_in_cache.insert(
-        std::make_pair(client.network_isolation_key, client.origin));
+        std::make_pair(client.network_anonymization_key, client.origin));
     // We have not seen a duplicate client with the same NIK and origin.
     DCHECK(inserted.second);
   }
@@ -1060,7 +1059,7 @@ size_t ReportingCacheImpl::ConsistencyCheckClient(const std::string& domain,
       // group.
       DCHECK(!key_and_group.first.IsDocumentEndpoint());
       if (key.origin == client.origin &&
-          key.network_isolation_key == client.network_isolation_key &&
+          key.network_anonymization_key == client.network_anonymization_key &&
           key.group_name == group_name) {
         ++endpoint_group_count_in_client;
         ++groups_with_name;
@@ -1138,14 +1137,14 @@ void ReportingCacheImpl::ConsistencyCheckEndpoint(
 }
 
 ReportingCacheImpl::ClientMap::iterator ReportingCacheImpl::FindClientIt(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin) {
   // TODO(chlily): Limit the number of clients per domain to prevent an attacker
   // from installing many Reporting policies for different port numbers on the
   // same host.
   const auto domain_range = clients_.equal_range(origin.host());
   for (auto it = domain_range.first; it != domain_range.second; ++it) {
-    if (it->second.network_isolation_key == network_isolation_key &&
+    if (it->second.network_anonymization_key == network_anonymization_key &&
         it->second.origin == origin) {
       return it;
     }
@@ -1155,7 +1154,7 @@ ReportingCacheImpl::ClientMap::iterator ReportingCacheImpl::FindClientIt(
 
 ReportingCacheImpl::ClientMap::iterator ReportingCacheImpl::FindClientIt(
     const ReportingEndpointGroupKey& group_key) {
-  return FindClientIt(group_key.network_isolation_key, group_key.origin);
+  return FindClientIt(group_key.network_anonymization_key, group_key.origin);
 }
 
 ReportingCacheImpl::EndpointGroupMap::iterator
@@ -1178,7 +1177,7 @@ ReportingCacheImpl::EndpointMap::iterator ReportingCacheImpl::FindEndpointIt(
 ReportingCacheImpl::ClientMap::iterator ReportingCacheImpl::AddOrUpdateClient(
     Client new_client) {
   ClientMap::iterator client_it =
-      FindClientIt(new_client.network_isolation_key, new_client.origin);
+      FindClientIt(new_client.network_anonymization_key, new_client.origin);
 
   // Add a new client for this NIK and origin.
   if (client_it == clients_.end()) {
@@ -1293,10 +1292,11 @@ void ReportingCacheImpl::RemoveEndpointsInGroupOtherThan(
 }
 
 void ReportingCacheImpl::RemoveEndpointGroupsForClientOtherThan(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin,
     const std::set<std::string>& groups_to_keep_names) {
-  ClientMap::iterator client_it = FindClientIt(network_isolation_key, origin);
+  ClientMap::iterator client_it =
+      FindClientIt(network_anonymization_key, origin);
   if (client_it == clients_.end())
     return;
 
@@ -1307,8 +1307,9 @@ void ReportingCacheImpl::RemoveEndpointGroupsForClientOtherThan(
                                                        groups_to_keep_names);
 
   for (const std::string& group_name : groups_to_remove_names) {
-    EndpointGroupMap::iterator group_it = FindEndpointGroupIt(
-        ReportingEndpointGroupKey(network_isolation_key, origin, group_name));
+    EndpointGroupMap::iterator group_it =
+        FindEndpointGroupIt(ReportingEndpointGroupKey(network_anonymization_key,
+                                                      origin, group_name));
     RemoveEndpointGroupInternal(client_it, group_it);
   }
 }
@@ -1419,7 +1420,7 @@ ReportingCacheImpl::RemoveClientInternal(ClientMap::iterator client_it) {
 
   // Erase all groups in this client, and all endpoints in those groups.
   for (const std::string& group_name : client.endpoint_group_names) {
-    ReportingEndpointGroupKey group_key(client.network_isolation_key,
+    ReportingEndpointGroupKey group_key(client.network_anonymization_key,
                                         client.origin, group_name);
     EndpointGroupMap::iterator group_it = FindEndpointGroupIt(group_key);
     if (context_->IsClientDataPersisted())
@@ -1480,8 +1481,8 @@ void ReportingCacheImpl::EvictEndpointsFromClient(ClientMap::iterator client_it,
   const Client& client = client_it->second;
   // Cache this value as |client| may be deleted.
   size_t client_endpoint_count = client.endpoint_count;
-  const NetworkIsolationKey& network_isolation_key =
-      client.network_isolation_key;
+  const NetworkAnonymizationKey& network_anonymization_key =
+      client.network_anonymization_key;
   const url::Origin& origin = client.origin;
 
   DCHECK_GE(client_endpoint_count, endpoints_to_evict);
@@ -1507,7 +1508,7 @@ void ReportingCacheImpl::EvictEndpointsFromClient(ClientMap::iterator client_it,
     EndpointGroupMap::iterator stalest_group_it = endpoint_groups_.end();
     size_t stalest_group_endpoint_count = 0;
     for (const std::string& group_name : client.endpoint_group_names) {
-      ReportingEndpointGroupKey group_key(network_isolation_key, origin,
+      ReportingEndpointGroupKey group_key(network_anonymization_key, origin,
                                           group_name);
       EndpointGroupMap::iterator group_it = FindEndpointGroupIt(group_key);
       size_t group_endpoint_count = GetEndpointCountInGroup(group_key);
@@ -1560,7 +1561,7 @@ bool ReportingCacheImpl::RemoveExpiredOrStaleGroups(
 
   for (const std::string& group_name : groups_in_client_names) {
     EndpointGroupMap::iterator group_it = FindEndpointGroupIt(
-        ReportingEndpointGroupKey(client_it->second.network_isolation_key,
+        ReportingEndpointGroupKey(client_it->second.network_anonymization_key,
                                   client_it->second.origin, group_name));
     DCHECK(group_it != endpoint_groups_.end());
     const CachedReportingEndpointGroup& group = group_it->second;
@@ -1599,13 +1600,13 @@ void ReportingCacheImpl::RemoveEndpointItFromIndex(
 
 base::Value ReportingCacheImpl::GetClientAsValue(const Client& client) const {
   base::Value::Dict client_dict;
-  client_dict.Set("network_isolation_key",
-                  client.network_isolation_key.ToDebugString());
+  client_dict.Set("network_anonymization_key",
+                  client.network_anonymization_key.ToDebugString());
   client_dict.Set("origin", client.origin.Serialize());
 
   base::Value::List group_list;
   for (const std::string& group_name : client.endpoint_group_names) {
-    ReportingEndpointGroupKey group_key(client.network_isolation_key,
+    ReportingEndpointGroupKey group_key(client.network_anonymization_key,
                                         client.origin, group_name);
     const CachedReportingEndpointGroup& group = endpoint_groups_.at(group_key);
     group_list.Append(GetEndpointGroupAsValue(group));
diff --git a/chromium/net/reporting/reporting_cache_impl.h b/chromium/net/reporting/reporting_cache_impl.h
index 4ffac185bb5..63949558f79 100644
--- a/chromium/net/reporting/reporting_cache_impl.h
+++ b/chromium/net/reporting/reporting_cache_impl.h
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2019 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -44,7 +44,7 @@ class ReportingCacheImpl : public ReportingCache {
 
   // ReportingCache implementation
   void AddReport(const absl::optional<base::UnguessableToken>& reporting_source,
-                 const NetworkIsolationKey& network_isolation_key,
+                 const NetworkAnonymizationKey& network_anonymization_key,
                  const GURL& url,
                  const std::string& user_agent,
                  const std::string& group_name,
@@ -84,7 +84,7 @@ class ReportingCacheImpl : public ReportingCache {
   bool IsReportPendingForTesting(const ReportingReport* report) const override;
   bool IsReportDoomedForTesting(const ReportingReport* report) const override;
   void OnParsedHeader(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       std::vector<ReportingEndpointGroup> parsed_header) override;
   void OnParsedReportingEndpointsHeader(
@@ -92,7 +92,7 @@ class ReportingCacheImpl : public ReportingCache {
       const IsolationInfo& isolation_info,
       std::vector<ReportingEndpoint> parsed_header) override;
   std::set<url::Origin> GetAllOrigins() const override;
-  void RemoveClient(const NetworkIsolationKey& network_isolation_key,
+  void RemoveClient(const NetworkAnonymizationKey& network_anonymization_key,
                     const url::Origin& origin) override;
   void RemoveClientsForOrigin(const url::Origin& origin) override;
   void RemoveAllClients() override;
@@ -118,8 +118,9 @@ class ReportingCacheImpl : public ReportingCache {
   bool EndpointGroupExistsForTesting(const ReportingEndpointGroupKey& group_key,
                                      OriginSubdomains include_subdomains,
                                      base::Time expires) const override;
-  bool ClientExistsForTesting(const NetworkIsolationKey& network_isolation_key,
-                              const url::Origin& origin) const override;
+  bool ClientExistsForTesting(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const url::Origin& origin) const override;
   size_t GetEndpointGroupCountForTesting() const override;
   size_t GetClientCountForTesting() const override;
   size_t GetReportingSourceCountForTesting() const override;
@@ -139,7 +140,7 @@ class ReportingCacheImpl : public ReportingCache {
  private:
   // Represents the entire Report-To configuration for a (NIK, origin) pair.
   struct Client {
-    Client(const NetworkIsolationKey& network_isolation_key,
+    Client(const NetworkAnonymizationKey& network_anonymization_key,
            const url::Origin& origin);
 
     Client(const Client& other);
@@ -152,7 +153,7 @@ class ReportingCacheImpl : public ReportingCache {
 
     // NIK of the context associated with this client. Needed to prevent leaking
     // third party contexts across sites.
-    NetworkIsolationKey network_isolation_key;
+    NetworkAnonymizationKey network_anonymization_key;
 
     // Origin that configured this client.
     url::Origin origin;
@@ -204,10 +205,10 @@ class ReportingCacheImpl : public ReportingCache {
                                 EndpointMap::const_iterator endpoint_it) const;
 #endif  // DCHECK_IS_ON()
 
-  // Finds iterator to the client with the given |network_isolation_key| and
+  // Finds iterator to the client with the given |network_anonymization_key| and
   // |origin|, if one exists. Returns |clients_.end()| if none is found.
   ClientMap::iterator FindClientIt(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin);
 
   // Overload that takes a ReportingEndpointGroupKey and finds the client
@@ -245,7 +246,7 @@ class ReportingCacheImpl : public ReportingCache {
   // in |groups_to_keep_names|. Does not guarantee that all the groups in
   // |groups_to_keep_names| exist in the cache for that client.
   void RemoveEndpointGroupsForClientOtherThan(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       const std::set<std::string>& groups_to_keep_names);
 
diff --git a/chromium/net/reporting/reporting_cache_observer.cc b/chromium/net/reporting/reporting_cache_observer.cc
index 4bbf45ffc35..edc3a0483a1 100644
--- a/chromium/net/reporting/reporting_cache_observer.cc
+++ b/chromium/net/reporting/reporting_cache_observer.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_cache_observer.h b/chromium/net/reporting/reporting_cache_observer.h
index 13853742698..7368d814fbf 100644
--- a/chromium/net/reporting/reporting_cache_observer.h
+++ b/chromium/net/reporting/reporting_cache_observer.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_cache_unittest.cc b/chromium/net/reporting/reporting_cache_unittest.cc
index d7669ca5a40..69e9fc13b69 100644
--- a/chromium/net/reporting/reporting_cache_unittest.cc
+++ b/chromium/net/reporting/reporting_cache_unittest.cc
@@ -1,14 +1,14 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/reporting/reporting_cache.h"
 
-#include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/containers/contains.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/scoped_feature_list.h"
@@ -17,7 +17,7 @@
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/features.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/reporting/mock_persistent_reporting_store.h"
 #include "net/reporting/reporting_cache_impl.h"
@@ -105,7 +105,7 @@ class ReportingCacheTest : public ReportingTestBase,
 
   // Adds a new report to the cache, and returns it.
   const ReportingReport* AddAndReturnReport(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const GURL& url,
       const std::string& user_agent,
       const std::string& group,
@@ -114,7 +114,7 @@ class ReportingCacheTest : public ReportingTestBase,
       int depth,
       base::TimeTicks queued,
       int attempts) {
-    const base::Value body_clone(body.Clone());
+    const base::Value::Dict body_clone(body.Clone());
 
     // The public API will only give us the (unordered) full list of reports in
     // the cache.  So we need to grab the list before we add, and the list after
@@ -122,20 +122,21 @@ class ReportingCacheTest : public ReportingTestBase,
     // in test cases, so I've optimized for readability over execution speed.
     std::vector<const ReportingReport*> before;
     cache()->GetReports(&before);
-    cache()->AddReport(absl::nullopt, network_isolation_key, url, user_agent,
-                       group, type, std::move(body), depth, queued, attempts);
+    cache()->AddReport(absl::nullopt, network_anonymization_key, url,
+                       user_agent, group, type, std::move(body), depth, queued,
+                       attempts);
     std::vector<const ReportingReport*> after;
     cache()->GetReports(&after);
 
     for (const ReportingReport* report : after) {
       // If report isn't in before, we've found the new instance.
       if (std::find(before.begin(), before.end(), report) == before.end()) {
-        EXPECT_EQ(network_isolation_key, report->network_isolation_key);
+        EXPECT_EQ(network_anonymization_key, report->network_anonymization_key);
         EXPECT_EQ(url, report->url);
         EXPECT_EQ(user_agent, report->user_agent);
         EXPECT_EQ(group, report->group);
         EXPECT_EQ(type, report->type);
-        EXPECT_EQ(body_clone, *report->body);
+        EXPECT_EQ(body_clone, report->body);
         EXPECT_EQ(depth, report->depth);
         EXPECT_EQ(queued, report->queued);
         EXPECT_EQ(attempts, report->attempts);
@@ -168,8 +169,8 @@ class ReportingCacheTest : public ReportingTestBase,
     if (exist) {
       EXPECT_EQ(endpoint1.group_key, group);
       EXPECT_EQ(endpoint2.group_key, group);
-      EXPECT_TRUE(cache()->ClientExistsForTesting(group.network_isolation_key,
-                                                  group.origin));
+      EXPECT_TRUE(cache()->ClientExistsForTesting(
+          group.network_anonymization_key, group.origin));
     }
     EXPECT_EQ(exist,
               EndpointGroupExistsInCache(group, OriginSubdomains::DEFAULT));
@@ -183,9 +184,10 @@ class ReportingCacheTest : public ReportingTestBase,
   const url::Origin kOrigin2_ = url::Origin::Create(GURL("https://origin2/"));
   const absl::optional<base::UnguessableToken> kReportingSource_ =
       base::UnguessableToken::Create();
-  const NetworkIsolationKey kNik_;
-  const NetworkIsolationKey kOtherNik_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin1_), SchemefulSite(kOrigin2_));
+  const NetworkAnonymizationKey kNak_;
+  const NetworkAnonymizationKey kOtherNak_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin1_),
+                              SchemefulSite(kOrigin2_));
   const IsolationInfo kIsolationInfo1_ =
       IsolationInfo::Create(IsolationInfo::RequestType::kOther,
                             kOrigin1_,
@@ -209,23 +211,23 @@ class ReportingCacheTest : public ReportingTestBase,
   const base::Time kExpires1_ = kNow_ + base::Days(7);
   const base::Time kExpires2_ = kExpires1_ + base::Days(7);
   // There are 2^3 = 8 of these to test the different combinations of matching
-  // vs mismatching NIK, origin, and group.
+  // vs mismatching NAK, origin, and group.
   const ReportingEndpointGroupKey kGroupKey11_ =
-      ReportingEndpointGroupKey(kNik_, kOrigin1_, kGroup1_);
+      ReportingEndpointGroupKey(kNak_, kOrigin1_, kGroup1_);
   const ReportingEndpointGroupKey kGroupKey21_ =
-      ReportingEndpointGroupKey(kNik_, kOrigin2_, kGroup1_);
+      ReportingEndpointGroupKey(kNak_, kOrigin2_, kGroup1_);
   const ReportingEndpointGroupKey kGroupKey12_ =
-      ReportingEndpointGroupKey(kNik_, kOrigin1_, kGroup2_);
+      ReportingEndpointGroupKey(kNak_, kOrigin1_, kGroup2_);
   const ReportingEndpointGroupKey kGroupKey22_ =
-      ReportingEndpointGroupKey(kNik_, kOrigin2_, kGroup2_);
+      ReportingEndpointGroupKey(kNak_, kOrigin2_, kGroup2_);
   const ReportingEndpointGroupKey kOtherGroupKey11_ =
-      ReportingEndpointGroupKey(kOtherNik_, kOrigin1_, kGroup1_);
+      ReportingEndpointGroupKey(kOtherNak_, kOrigin1_, kGroup1_);
   const ReportingEndpointGroupKey kOtherGroupKey21_ =
-      ReportingEndpointGroupKey(kOtherNik_, kOrigin2_, kGroup1_);
+      ReportingEndpointGroupKey(kOtherNak_, kOrigin2_, kGroup1_);
   const ReportingEndpointGroupKey kOtherGroupKey12_ =
-      ReportingEndpointGroupKey(kOtherNik_, kOrigin1_, kGroup2_);
+      ReportingEndpointGroupKey(kOtherNak_, kOrigin1_, kGroup2_);
   const ReportingEndpointGroupKey kOtherGroupKey22_ =
-      ReportingEndpointGroupKey(kOtherNik_, kOrigin2_, kGroup2_);
+      ReportingEndpointGroupKey(kOtherNak_, kOrigin2_, kGroup2_);
 
   TestReportingCacheObserver observer_;
   std::unique_ptr<MockPersistentReportingStore> store_;
@@ -243,7 +245,7 @@ TEST_P(ReportingCacheTest, Reports) {
   cache()->GetReports(&reports);
   EXPECT_TRUE(reports.empty());
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
   EXPECT_EQ(1, observer()->cached_reports_update_count());
 
@@ -251,7 +253,7 @@ TEST_P(ReportingCacheTest, Reports) {
   ASSERT_EQ(1u, reports.size());
   const ReportingReport* report = reports[0];
   ASSERT_TRUE(report);
-  EXPECT_EQ(kNik_, report->network_isolation_key);
+  EXPECT_EQ(kNak_, report->network_anonymization_key);
   EXPECT_EQ(kUrl1_, report->url);
   EXPECT_EQ(kUserAgent_, report->user_agent);
   EXPECT_EQ(kGroup1_, report->group);
@@ -281,9 +283,9 @@ TEST_P(ReportingCacheTest, Reports) {
 TEST_P(ReportingCacheTest, RemoveAllReports) {
   LoadReportingClients();
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
   EXPECT_EQ(2, observer()->cached_reports_update_count());
 
@@ -301,7 +303,7 @@ TEST_P(ReportingCacheTest, RemoveAllReports) {
 TEST_P(ReportingCacheTest, RemovePendingReports) {
   LoadReportingClients();
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
   EXPECT_EQ(1, observer()->cached_reports_update_count());
 
@@ -338,7 +340,7 @@ TEST_P(ReportingCacheTest, RemovePendingReports) {
 TEST_P(ReportingCacheTest, RemoveAllPendingReports) {
   LoadReportingClients();
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
   EXPECT_EQ(1, observer()->cached_reports_update_count());
 
@@ -378,10 +380,10 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
   // We need a reproducible expiry timestamp for this test case.
   const base::TimeTicks now = base::TimeTicks();
   const ReportingReport* report1 =
-      AddAndReturnReport(kNik_, kUrl1_, kUserAgent_, kGroup1_, kType_,
+      AddAndReturnReport(kNak_, kUrl1_, kUserAgent_, kGroup1_, kType_,
                          base::Value::Dict(), 0, now + base::Seconds(200), 0);
   const ReportingReport* report2 =
-      AddAndReturnReport(kOtherNik_, kUrl1_, kUserAgent_, kGroup2_, kType_,
+      AddAndReturnReport(kOtherNak_, kUrl1_, kUserAgent_, kGroup2_, kType_,
                          base::Value::Dict(), 0, now + base::Seconds(100), 1);
   // Mark report1 and report2 as pending.
   EXPECT_THAT(cache()->GetReportsToDeliver(),
@@ -396,7 +398,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin1/path",
           "group": "group2",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "doomed",
           "body": {},
@@ -407,7 +409,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin1/path",
           "group": "group1",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "pending",
           "body": {},
@@ -417,15 +419,15 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         },
       ]
       )json",
-      kOtherNik_.ToDebugString().c_str(), kNik_.ToDebugString().c_str()));
+      kOtherNak_.ToDebugString().c_str(), kNak_.ToDebugString().c_str()));
   EXPECT_EQ(expected, actual);
 
   // Add two new reports that will show up as "queued".
   const ReportingReport* report3 =
-      AddAndReturnReport(kNik_, kUrl2_, kUserAgent_, kGroup1_, kType_,
+      AddAndReturnReport(kNak_, kUrl2_, kUserAgent_, kGroup1_, kType_,
                          base::Value::Dict(), 2, now + base::Seconds(200), 0);
   const ReportingReport* report4 =
-      AddAndReturnReport(kOtherNik_, kUrl1_, kUserAgent_, kGroup1_, kType_,
+      AddAndReturnReport(kOtherNak_, kUrl1_, kUserAgent_, kGroup1_, kType_,
                          base::Value::Dict(), 0, now + base::Seconds(300), 0);
   actual = cache()->GetReportsAsValue();
   expected = base::test::ParseJson(base::StringPrintf(
@@ -434,7 +436,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin1/path",
           "group": "group2",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "doomed",
           "body": {},
@@ -445,7 +447,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin1/path",
           "group": "group1",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "pending",
           "body": {},
@@ -456,7 +458,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin2/path",
           "group": "group1",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "queued",
           "body": {},
@@ -467,7 +469,7 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         {
           "url": "https://origin1/path",
           "group": "group1",
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "type": "default",
           "status": "queued",
           "body": {},
@@ -477,8 +479,8 @@ TEST_P(ReportingCacheTest, GetReportsAsValue) {
         },
       ]
       )json",
-      kOtherNik_.ToDebugString().c_str(), kNik_.ToDebugString().c_str(),
-      kNik_.ToDebugString().c_str(), kOtherNik_.ToDebugString().c_str()));
+      kOtherNak_.ToDebugString().c_str(), kNak_.ToDebugString().c_str(),
+      kNak_.ToDebugString().c_str(), kOtherNak_.ToDebugString().c_str()));
   EXPECT_EQ(expected, actual);
 
   // GetReportsToDeliver only returns the non-pending reports.
@@ -494,11 +496,11 @@ TEST_P(ReportingCacheTest, GetReportsToDeliverForSource) {
 
   // Queue a V1 report for each of these sources, and a V0 report (with a null
   // source) for the same URL.
-  cache()->AddReport(source1, kNik_, kUrl1_, kUserAgent_, kGroup1_, kType_,
+  cache()->AddReport(source1, kNak_, kUrl1_, kUserAgent_, kGroup1_, kType_,
                      base::Value::Dict(), 0, kNowTicks_, 0);
-  cache()->AddReport(source2, kNik_, kUrl1_, kUserAgent_, kGroup1_, kType_,
+  cache()->AddReport(source2, kNak_, kUrl1_, kUserAgent_, kGroup1_, kType_,
                      base::Value::Dict(), 0, kNowTicks_, 0);
-  cache()->AddReport(absl::nullopt, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(absl::nullopt, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
   EXPECT_EQ(3, observer()->cached_reports_update_count());
 
@@ -655,13 +657,13 @@ TEST_P(ReportingCacheTest, ClientsKeyedByEndpointGroupKey) {
   size_t client_count = 4u;
   EXPECT_EQ(client_count, cache()->GetClientCountForTesting());
 
-  // Test that Clients with different NIKs are considered different, and test
+  // Test that Clients with different NAKs are considered different, and test
   // RemoveEndpointGroup() and RemoveClient().
-  const std::pair<NetworkIsolationKey, url::Origin> kNikOriginPairs[] = {
-      {kNik_, kOrigin1_},
-      {kNik_, kOrigin2_},
-      {kOtherNik_, kOrigin1_},
-      {kOtherNik_, kOrigin2_},
+  const std::pair<NetworkAnonymizationKey, url::Origin> kNakOriginPairs[] = {
+      {kNak_, kOrigin1_},
+      {kNak_, kOrigin2_},
+      {kOtherNak_, kOrigin1_},
+      {kOtherNak_, kOrigin2_},
   };
 
   // SetEndpointInCache doesn't update store counts, which is why we start from
@@ -674,7 +676,7 @@ TEST_P(ReportingCacheTest, ClientsKeyedByEndpointGroupKey) {
   int store_remove_group_count = 0;
   int store_remove_endpoint_count = 0;
 
-  for (const auto& pair : kNikOriginPairs) {
+  for (const auto& pair : kNakOriginPairs) {
     EXPECT_TRUE(cache()->ClientExistsForTesting(pair.first, pair.second));
     ReportingEndpointGroupKey group1(pair.first, pair.second, kGroup1_);
     ReportingEndpointGroupKey group2(pair.first, pair.second, kGroup2_);
@@ -952,21 +954,21 @@ TEST_P(ReportingCacheTest, RemoveSourceAndEndpoints) {
       base::UnguessableToken::Create();
   LoadReportingClients();
 
-  NetworkIsolationKey network_isolation_key_1 =
-      kIsolationInfo1_.network_isolation_key();
-  NetworkIsolationKey network_isolation_key_2 =
-      kIsolationInfo2_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key_1 =
+      kIsolationInfo1_.network_anonymization_key();
+  NetworkAnonymizationKey network_anonymization_key_2 =
+      kIsolationInfo2_.network_anonymization_key();
 
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_1, *kReportingSource_,
+      ReportingEndpointGroupKey(network_anonymization_key_1, *kReportingSource_,
                                 kOrigin1_, kGroup1_),
       *kReportingSource_, kIsolationInfo1_, kUrl1_);
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_1, *kReportingSource_,
+      ReportingEndpointGroupKey(network_anonymization_key_1, *kReportingSource_,
                                 kOrigin1_, kGroup2_),
       *kReportingSource_, kIsolationInfo1_, kUrl2_);
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_2, reporting_source_2,
+      ReportingEndpointGroupKey(network_anonymization_key_2, reporting_source_2,
                                 kOrigin2_, kGroup1_),
       reporting_source_2, kIsolationInfo2_, kUrl2_);
 
@@ -1019,7 +1021,7 @@ TEST_P(ReportingCacheTest, GetClientsAsValue) {
       R"json(
       [
         {
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "origin": "https://origin1",
           "groups": [
             {
@@ -1035,7 +1037,7 @@ TEST_P(ReportingCacheTest, GetClientsAsValue) {
           ],
         },
         {
-          "network_isolation_key": "%s",
+          "network_anonymization_key": "%s",
           "origin": "https://origin2",
           "groups": [
             {
@@ -1052,7 +1054,7 @@ TEST_P(ReportingCacheTest, GetClientsAsValue) {
         },
       ]
       )json",
-      kNik_.ToDebugString().c_str(), kOtherNik_.ToDebugString().c_str()));
+      kNak_.ToDebugString().c_str(), kOtherNak_.ToDebugString().c_str()));
 
   // Compare disregarding order.
   base::Value::List& expected_list = expected.GetList();
@@ -1086,16 +1088,16 @@ TEST_P(ReportingCacheTest, GetCandidateEndpointsFromDocumentForDelivery) {
   const base::UnguessableToken reporting_source_2 =
       base::UnguessableToken::Create();
 
-  NetworkIsolationKey network_isolation_key =
-      kIsolationInfo1_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key =
+      kIsolationInfo1_.network_anonymization_key();
   const ReportingEndpointGroupKey document_group_key_1 =
-      ReportingEndpointGroupKey(network_isolation_key, reporting_source_1,
+      ReportingEndpointGroupKey(network_anonymization_key, reporting_source_1,
                                 kOrigin1_, kGroup1_);
   const ReportingEndpointGroupKey document_group_key_2 =
-      ReportingEndpointGroupKey(network_isolation_key, reporting_source_1,
+      ReportingEndpointGroupKey(network_anonymization_key, reporting_source_1,
                                 kOrigin1_, kGroup2_);
   const ReportingEndpointGroupKey document_group_key_3 =
-      ReportingEndpointGroupKey(network_isolation_key, reporting_source_2,
+      ReportingEndpointGroupKey(network_anonymization_key, reporting_source_2,
                                 kOrigin1_, kGroup1_);
 
   SetV1EndpointInCache(document_group_key_1, reporting_source_1,
@@ -1105,7 +1107,7 @@ TEST_P(ReportingCacheTest, GetCandidateEndpointsFromDocumentForDelivery) {
   SetV1EndpointInCache(document_group_key_3, reporting_source_2,
                        kIsolationInfo1_, kEndpoint1_);
   const ReportingEndpointGroupKey kReportGroupKey = ReportingEndpointGroupKey(
-      network_isolation_key, reporting_source_1, kOrigin1_, kGroup1_);
+      network_anonymization_key, reporting_source_1, kOrigin1_, kGroup1_);
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(kReportGroupKey);
   ASSERT_EQ(1u, candidate_endpoints.size());
@@ -1118,17 +1120,17 @@ TEST_P(ReportingCacheTest, GetCandidateEndpointsFromDocumentForNetworkReports) {
   const base::UnguessableToken reporting_source =
       base::UnguessableToken::Create();
 
-  NetworkIsolationKey network_isolation_key =
-      kIsolationInfo1_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key =
+      kIsolationInfo1_.network_anonymization_key();
 
   const ReportingEndpointGroupKey kDocumentGroupKey = ReportingEndpointGroupKey(
-      network_isolation_key, reporting_source, kOrigin1_, kGroup1_);
+      network_anonymization_key, reporting_source, kOrigin1_, kGroup1_);
 
   SetV1EndpointInCache(kDocumentGroupKey, reporting_source, kIsolationInfo1_,
                        kEndpoint1_);
   const ReportingEndpointGroupKey kNetworkReportGroupKey =
-      ReportingEndpointGroupKey(network_isolation_key, absl::nullopt, kOrigin1_,
-                                kGroup1_);
+      ReportingEndpointGroupKey(network_anonymization_key, absl::nullopt,
+                                kOrigin1_, kGroup1_);
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(kNetworkReportGroupKey);
   ASSERT_EQ(0u, candidate_endpoints.size());
@@ -1140,16 +1142,16 @@ TEST_P(ReportingCacheTest, GetCandidateEndpointsFromDifferentDocument) {
   const base::UnguessableToken reporting_source =
       base::UnguessableToken::Create();
 
-  NetworkIsolationKey network_isolation_key =
-      kIsolationInfo1_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key =
+      kIsolationInfo1_.network_anonymization_key();
 
   const ReportingEndpointGroupKey kDocumentGroupKey = ReportingEndpointGroupKey(
-      network_isolation_key, reporting_source, kOrigin1_, kGroup1_);
+      network_anonymization_key, reporting_source, kOrigin1_, kGroup1_);
 
   SetV1EndpointInCache(kDocumentGroupKey, reporting_source, kIsolationInfo1_,
                        kEndpoint1_);
   const ReportingEndpointGroupKey kOtherGroupKey = ReportingEndpointGroupKey(
-      network_isolation_key, base::UnguessableToken::Create(), kOrigin1_,
+      network_anonymization_key, base::UnguessableToken::Create(), kOrigin1_,
       kGroup1_);
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(kOtherGroupKey);
@@ -1163,12 +1165,12 @@ TEST_P(ReportingCacheTest, GetCandidateEndpointsFromDifferentDocument) {
 TEST_P(ReportingCacheTest, GetMixedCandidateEndpointsForDelivery) {
   LoadReportingClients();
 
-  // This test relies on proper NIKs being used, so set those up, and endpoint
+  // This test relies on proper NAKs being used, so set those up, and endpoint
   // group keys to go with them.
-  NetworkIsolationKey network_isolation_key1 =
-      kIsolationInfo1_.network_isolation_key();
-  NetworkIsolationKey network_isolation_key2 =
-      kIsolationInfo2_.network_isolation_key();
+  NetworkAnonymizationKey network_isolation_key1 =
+      kIsolationInfo1_.network_anonymization_key();
+  NetworkAnonymizationKey network_isolation_key2 =
+      kIsolationInfo2_.network_anonymization_key();
   ReportingEndpointGroupKey group_key_11 =
       ReportingEndpointGroupKey(network_isolation_key1, kOrigin1_, kGroup1_);
   ReportingEndpointGroupKey group_key_12 =
@@ -1183,8 +1185,8 @@ TEST_P(ReportingCacheTest, GetMixedCandidateEndpointsForDelivery) {
   ASSERT_TRUE(SetEndpointInCache(group_key_21, kEndpoint1_, kExpires1_));
 
   // Set up a V1 endpoint for a document at the same origin.
-  NetworkIsolationKey network_isolation_key =
-      kIsolationInfo1_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key =
+      kIsolationInfo1_.network_anonymization_key();
   const base::UnguessableToken reporting_source =
       base::UnguessableToken::Create();
   const ReportingEndpointGroupKey document_group_key =
@@ -1219,11 +1221,11 @@ TEST_P(ReportingCacheTest, GetMixedCandidateEndpointsForDelivery) {
   EXPECT_EQ(group_key_12, candidate_endpoints[0].group_key);
 }
 
-TEST_P(ReportingCacheTest, GetCandidateEndpointsDifferentNik) {
+TEST_P(ReportingCacheTest, GetCandidateEndpointsDifferentNak) {
   LoadReportingClients();
 
-  // Test that NIKs are respected by using 2 groups with the same origin and
-  // group name but different NIKs.
+  // Test that NAKs are respected by using 2 groups with the same origin and
+  // group name but different NAKs.
   ASSERT_TRUE(SetEndpointInCache(kGroupKey11_, kEndpoint1_, kExpires1_));
   ASSERT_TRUE(SetEndpointInCache(kGroupKey11_, kEndpoint2_, kExpires1_));
   ASSERT_TRUE(SetEndpointInCache(kOtherGroupKey11_, kEndpoint1_, kExpires1_));
@@ -1274,12 +1276,12 @@ TEST_P(ReportingCacheTest, ExcludeSubdomainsDifferentPort) {
       url::Origin::Create(GURL("https://example:444/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kDifferentPortOrigin, kGroup1_),
+      ReportingEndpointGroupKey(kNak_, kDifferentPortOrigin, kGroup1_),
       kEndpoint1_, kExpires1_, OriginSubdomains::EXCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(0u, candidate_endpoints.size());
 }
 
@@ -1291,12 +1293,12 @@ TEST_P(ReportingCacheTest, ExcludeSubdomainsSuperdomain) {
       url::Origin::Create(GURL("https://example/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperOrigin, kGroup1_), kEndpoint1_,
+      ReportingEndpointGroupKey(kNak_, kSuperOrigin, kGroup1_), kEndpoint1_,
       kExpires1_, OriginSubdomains::EXCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(0u, candidate_endpoints.size());
 }
 
@@ -1308,12 +1310,12 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsDifferentPort) {
       url::Origin::Create(GURL("https://example:444/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kDifferentPortOrigin, kGroup1_),
+      ReportingEndpointGroupKey(kNak_, kDifferentPortOrigin, kGroup1_),
       kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
   EXPECT_EQ(kDifferentPortOrigin, candidate_endpoints[0].group_key.origin);
 }
@@ -1326,12 +1328,12 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsSuperdomain) {
       url::Origin::Create(GURL("https://example/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperOrigin, kGroup1_), kEndpoint1_,
+      ReportingEndpointGroupKey(kNak_, kSuperOrigin, kGroup1_), kEndpoint1_,
       kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
   EXPECT_EQ(kSuperOrigin, candidate_endpoints[0].group_key.origin);
 }
@@ -1344,15 +1346,15 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsPreferOriginToDifferentPort) {
       url::Origin::Create(GURL("https://example:444/"));
 
   ASSERT_TRUE(
-      SetEndpointInCache(ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_),
+      SetEndpointInCache(ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_),
                          kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kDifferentPortOrigin, kGroup1_),
+      ReportingEndpointGroupKey(kNak_, kDifferentPortOrigin, kGroup1_),
       kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
   EXPECT_EQ(kOrigin, candidate_endpoints[0].group_key.origin);
 }
@@ -1365,15 +1367,15 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsPreferOriginToSuperdomain) {
       url::Origin::Create(GURL("https://example/"));
 
   ASSERT_TRUE(
-      SetEndpointInCache(ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_),
+      SetEndpointInCache(ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_),
                          kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperOrigin, kGroup1_), kEndpoint1_,
+      ReportingEndpointGroupKey(kNak_, kSuperOrigin, kGroup1_), kEndpoint1_,
       kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
   EXPECT_EQ(kOrigin, candidate_endpoints[0].group_key.origin);
 }
@@ -1389,20 +1391,20 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsPreferMoreSpecificSuperdomain) {
       url::Origin::Create(GURL("https://example/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperOrigin, kGroup1_), kEndpoint1_,
+      ReportingEndpointGroupKey(kNak_, kSuperOrigin, kGroup1_), kEndpoint1_,
       kExpires1_, OriginSubdomains::INCLUDE));
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperSuperOrigin, kGroup1_),
+      ReportingEndpointGroupKey(kNak_, kSuperSuperOrigin, kGroup1_),
       kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
   EXPECT_EQ(kSuperOrigin, candidate_endpoints[0].group_key.origin);
 }
 
-TEST_P(ReportingCacheTest, IncludeSubdomainsPreserveNik) {
+TEST_P(ReportingCacheTest, IncludeSubdomainsPreserveNak) {
   LoadReportingClients();
 
   const url::Origin kOrigin = url::Origin::Create(GURL("https://foo.example/"));
@@ -1410,17 +1412,18 @@ TEST_P(ReportingCacheTest, IncludeSubdomainsPreserveNik) {
       url::Origin::Create(GURL("https://example/"));
 
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kNik_, kSuperOrigin, kGroup1_), kEndpoint1_,
+      ReportingEndpointGroupKey(kNak_, kSuperOrigin, kGroup1_), kEndpoint1_,
       kExpires1_, OriginSubdomains::INCLUDE));
   ASSERT_TRUE(SetEndpointInCache(
-      ReportingEndpointGroupKey(kOtherNik_, kSuperOrigin, kGroup1_),
+      ReportingEndpointGroupKey(kOtherNak_, kSuperOrigin, kGroup1_),
       kEndpoint1_, kExpires1_, OriginSubdomains::INCLUDE));
 
   std::vector<ReportingEndpoint> candidate_endpoints =
       cache()->GetCandidateEndpointsForDelivery(
-          ReportingEndpointGroupKey(kOtherNik_, kOrigin, kGroup1_));
+          ReportingEndpointGroupKey(kOtherNak_, kOrigin, kGroup1_));
   ASSERT_EQ(1u, candidate_endpoints.size());
-  EXPECT_EQ(kOtherNik_, candidate_endpoints[0].group_key.network_isolation_key);
+  EXPECT_EQ(kOtherNak_,
+            candidate_endpoints[0].group_key.network_anonymization_key);
 }
 
 TEST_P(ReportingCacheTest, EvictOldestReport) {
@@ -1435,7 +1438,7 @@ TEST_P(ReportingCacheTest, EvictOldestReport) {
 
   // Enqueue the maximum number of reports, spaced apart in time.
   for (size_t i = 0; i < max_report_count; ++i) {
-    cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+    cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                        kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                        0);
     tick_clock()->Advance(base::Minutes(1));
@@ -1443,7 +1446,7 @@ TEST_P(ReportingCacheTest, EvictOldestReport) {
   EXPECT_EQ(max_report_count, report_count());
 
   // Add one more report to force the cache to evict one.
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                      0);
 
@@ -1467,7 +1470,7 @@ TEST_P(ReportingCacheTest, DontEvictPendingReports) {
   // Enqueue the maximum number of reports, spaced apart in time.
   std::vector<const ReportingReport*> reports;
   for (size_t i = 0; i < max_report_count; ++i) {
-    reports.push_back(AddAndReturnReport(kNik_, kUrl1_, kUserAgent_, kGroup1_,
+    reports.push_back(AddAndReturnReport(kNak_, kUrl1_, kUserAgent_, kGroup1_,
                                          kType_, base::Value::Dict(), 0,
                                          tick_clock()->NowTicks(), 0));
     tick_clock()->Advance(base::Minutes(1));
@@ -1480,7 +1483,7 @@ TEST_P(ReportingCacheTest, DontEvictPendingReports) {
 
   // Add one more report to force the cache to evict one. Since the cache has
   // only pending reports, it will be forced to evict the *new* report!
-  cache()->AddReport(kReportingSource_, kNik_, kUrl1_, kUserAgent_, kGroup1_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl1_, kUserAgent_, kGroup1_,
                      kType_, base::Value::Dict(), 0, kNowTicks_, 0);
 
   // Make sure the cache evicted a report, and make sure the report evicted was
@@ -1562,7 +1565,7 @@ TEST_P(ReportingCacheTest, EvictFromStalestGroup) {
   LoadReportingClients();
 
   for (size_t i = 0; i < policy().max_endpoints_per_origin; ++i) {
-    ReportingEndpointGroupKey group_key(kNik_, kOrigin1_,
+    ReportingEndpointGroupKey group_key(kNak_, kOrigin1_,
                                         base::NumberToString(i));
     ASSERT_TRUE(SetEndpointInCache(group_key, MakeURL(i), kExpires1_));
     EXPECT_EQ(i + 1, cache()->GetEndpointCount());
@@ -1581,12 +1584,12 @@ TEST_P(ReportingCacheTest, EvictFromStalestGroup) {
   EXPECT_GE(policy().max_endpoints_per_origin, cache()->GetEndpointCount());
   EXPECT_TRUE(ClientExistsInCacheForOrigin(kOrigin1_));
   EXPECT_FALSE(EndpointGroupExistsInCache(
-      ReportingEndpointGroupKey(kNik_, kOrigin1_, "0"),
+      ReportingEndpointGroupKey(kNak_, kOrigin1_, "0"),
       OriginSubdomains::DEFAULT));
   EXPECT_TRUE(
       EndpointGroupExistsInCache(kGroupKey12_, OriginSubdomains::DEFAULT));
   for (size_t i = 1; i < policy().max_endpoints_per_origin; ++i) {
-    ReportingEndpointGroupKey group_key(kNik_, kOrigin1_,
+    ReportingEndpointGroupKey group_key(kNak_, kOrigin1_,
                                         base::NumberToString(i));
     EXPECT_TRUE(
         EndpointGroupExistsInCache(group_key, OriginSubdomains::DEFAULT));
@@ -1606,7 +1609,7 @@ TEST_P(ReportingCacheTest, EvictFromLargestGroup) {
 
   // Insert one more endpoint in a different group; eviction should be
   // triggered.
-  SetEndpointInCache(ReportingEndpointGroupKey(kNik_, kOrigin1_, "default"),
+  SetEndpointInCache(ReportingEndpointGroupKey(kNak_, kOrigin1_, "default"),
                      kEndpoint1_, kExpires1_);
   EXPECT_EQ(policy().max_endpoints_per_origin, cache()->GetEndpointCount());
 
@@ -1649,12 +1652,21 @@ TEST_P(ReportingCacheTest, EvictLeastImportantEndpoint) {
   EXPECT_TRUE(FindEndpointInCache(kGroupKey12_, kEndpoint1_));
 }
 
-TEST_P(ReportingCacheTest, EvictEndpointsOverGlobalLimitFromStalestClient) {
+// Test is flaky on Linux (https://crbug.com/1358967)
+#if BUILDFLAG(IS_LINUX)
+#define MAYBE_EvictEndpointsOverGlobalLimitFromStalestClient \
+  DISABLED_EvictEndpointsOverGlobalLimitFromStalestClient
+#else
+#define MAYBE_EvictEndpointsOverGlobalLimitFromStalestClient \
+  EvictEndpointsOverGlobalLimitFromStalestClient
+#endif
+TEST_P(ReportingCacheTest,
+       MAYBE_EvictEndpointsOverGlobalLimitFromStalestClient) {
   LoadReportingClients();
 
   // Set enough endpoints to reach the global endpoint limit.
   for (size_t i = 0; i < policy().max_endpoint_count; ++i) {
-    ReportingEndpointGroupKey group_key(kNik_, url::Origin::Create(MakeURL(i)),
+    ReportingEndpointGroupKey group_key(kNak_, url::Origin::Create(MakeURL(i)),
                                         kGroup1_);
     ASSERT_TRUE(SetEndpointInCache(group_key, MakeURL(i), kExpires1_));
     EXPECT_EQ(i + 1, cache()->GetEndpointCount());
@@ -1719,13 +1731,14 @@ TEST_P(ReportingCacheTest, AddClientsLoadedFromStore) {
   EXPECT_TRUE(ClientExistsInCacheForOrigin(kOrigin2_));
 }
 
-TEST_P(ReportingCacheTest, AddStoredClientsWithDifferentNetworkIsolationKeys) {
+TEST_P(ReportingCacheTest,
+       AddStoredClientsWithDifferentNetworkAnonymizationKeys) {
   if (!store())
     return;
 
   base::Time now = clock()->Now();
 
-  // This should create 4 different clients, for (2 origins) x (2 NIKs).
+  // This should create 4 different clients, for (2 origins) x (2 NAKs).
   // Intentionally in a weird order to check sorting.
   std::vector<ReportingEndpoint> endpoints;
   endpoints.emplace_back(kGroupKey11_,
@@ -1766,13 +1779,13 @@ TEST_P(ReportingCacheTest, AddStoredClientsWithDifferentNetworkIsolationKeys) {
   EXPECT_TRUE(
       EndpointGroupExistsInCache(kOtherGroupKey21_, OriginSubdomains::DEFAULT));
   EXPECT_TRUE(cache()->ClientExistsForTesting(
-      kGroupKey11_.network_isolation_key, kGroupKey11_.origin));
+      kGroupKey11_.network_anonymization_key, kGroupKey11_.origin));
   EXPECT_TRUE(cache()->ClientExistsForTesting(
-      kGroupKey21_.network_isolation_key, kGroupKey21_.origin));
+      kGroupKey21_.network_anonymization_key, kGroupKey21_.origin));
   EXPECT_TRUE(cache()->ClientExistsForTesting(
-      kOtherGroupKey11_.network_isolation_key, kOtherGroupKey11_.origin));
+      kOtherGroupKey11_.network_anonymization_key, kOtherGroupKey11_.origin));
   EXPECT_TRUE(cache()->ClientExistsForTesting(
-      kOtherGroupKey21_.network_isolation_key, kOtherGroupKey21_.origin));
+      kOtherGroupKey21_.network_anonymization_key, kOtherGroupKey21_.origin));
 }
 
 TEST_P(ReportingCacheTest, DoNotStoreMoreThanLimits) {
@@ -1840,7 +1853,7 @@ TEST_P(ReportingCacheTest, DoNotLoadMismatchedGroupsAndEndpoints) {
   groups.emplace_back(kGroupKey21_, OriginSubdomains::DEFAULT,
                       now /* expires */, now /* last_used */);
   // This endpoint group has no corresponding endpoint
-  groups.emplace_back(ReportingEndpointGroupKey(kNik_, kOrigin2_, "last_group"),
+  groups.emplace_back(ReportingEndpointGroupKey(kNak_, kOrigin2_, "last_group"),
                       OriginSubdomains::DEFAULT, now /* expires */,
                       now /* last_used */);
   store()->SetPrestoredClients(endpoints, groups);
@@ -1874,10 +1887,10 @@ TEST_P(ReportingCacheTest, StoreLastUsedProperly) {
 
   // We need more than three endpoints to trigger eviction.
   std::vector<ReportingEndpoint> endpoints;
-  ReportingEndpointGroupKey group1(kNik_, kOrigin1_, "1");
-  ReportingEndpointGroupKey group2(kNik_, kOrigin1_, "2");
-  ReportingEndpointGroupKey group3(kNik_, kOrigin1_, "3");
-  ReportingEndpointGroupKey group4(kNik_, kOrigin1_, "4");
+  ReportingEndpointGroupKey group1(kNak_, kOrigin1_, "1");
+  ReportingEndpointGroupKey group2(kNak_, kOrigin1_, "2");
+  ReportingEndpointGroupKey group3(kNak_, kOrigin1_, "3");
+  ReportingEndpointGroupKey group4(kNak_, kOrigin1_, "4");
   endpoints.emplace_back(group1, ReportingEndpoint::EndpointInfo{kEndpoint1_});
   endpoints.emplace_back(group2, ReportingEndpoint::EndpointInfo{kEndpoint1_});
   endpoints.emplace_back(group3, ReportingEndpoint::EndpointInfo{kEndpoint1_});
@@ -1942,8 +1955,8 @@ TEST_P(ReportingCacheTest, DoNotAddDuplicatedEntriesFromStore) {
 TEST_P(ReportingCacheTest, GetIsolationInfoForEndpoint) {
   LoadReportingClients();
 
-  NetworkIsolationKey network_isolation_key1 =
-      kIsolationInfo1_.network_isolation_key();
+  NetworkAnonymizationKey network_isolation_key1 =
+      kIsolationInfo1_.network_anonymization_key();
 
   // Set up a V1 endpoint for this origin.
   cache()->SetV1EndpointForTesting(
@@ -1967,7 +1980,7 @@ TEST_P(ReportingCacheTest, GetIsolationInfoForEndpoint) {
   EXPECT_EQ(isolation_info_for_document.request_type(),
             IsolationInfo::RequestType::kOther);
 
-  // For a V0 endpoint, ensure that site_for_cookies is null and that the NIK
+  // For a V0 endpoint, ensure that site_for_cookies is null and that the NAK
   // matches the cached endpoint.
   ReportingEndpoint network_endpoint =
       cache()->GetEndpointForTesting(group_key_11, kEndpoint1_);
@@ -1976,8 +1989,8 @@ TEST_P(ReportingCacheTest, GetIsolationInfoForEndpoint) {
       cache()->GetIsolationInfoForEndpoint(network_endpoint);
   EXPECT_EQ(isolation_info_for_network.request_type(),
             IsolationInfo::RequestType::kOther);
-  EXPECT_EQ(isolation_info_for_network.network_isolation_key(),
-            network_endpoint.group_key.network_isolation_key);
+  EXPECT_EQ(isolation_info_for_network.network_anonymization_key(),
+            network_endpoint.group_key.network_anonymization_key);
   EXPECT_TRUE(isolation_info_for_network.site_for_cookies().IsNull());
 }
 
@@ -1986,22 +1999,22 @@ TEST_P(ReportingCacheTest, GetV1ReportingEndpointsForOrigin) {
       base::UnguessableToken::Create();
   LoadReportingClients();
 
-  NetworkIsolationKey network_isolation_key_1 =
-      kIsolationInfo1_.network_isolation_key();
-  NetworkIsolationKey network_isolation_key_2 =
-      kIsolationInfo2_.network_isolation_key();
+  NetworkAnonymizationKey network_anonymization_key_1 =
+      kIsolationInfo1_.network_anonymization_key();
+  NetworkAnonymizationKey network_anonymization_key_2 =
+      kIsolationInfo2_.network_anonymization_key();
 
   // Store endpoints from different origins in cache
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_1, *kReportingSource_,
+      ReportingEndpointGroupKey(network_anonymization_key_1, *kReportingSource_,
                                 kOrigin1_, kGroup1_),
       *kReportingSource_, kIsolationInfo1_, kUrl1_);
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_1, *kReportingSource_,
+      ReportingEndpointGroupKey(network_anonymization_key_1, *kReportingSource_,
                                 kOrigin1_, kGroup2_),
       *kReportingSource_, kIsolationInfo1_, kUrl2_);
   cache()->SetV1EndpointForTesting(
-      ReportingEndpointGroupKey(network_isolation_key_2, reporting_source_2,
+      ReportingEndpointGroupKey(network_anonymization_key_2, reporting_source_2,
                                 kOrigin2_, kGroup1_),
       reporting_source_2, kIsolationInfo2_, kUrl2_);
 
@@ -2010,17 +2023,17 @@ TEST_P(ReportingCacheTest, GetV1ReportingEndpointsForOrigin) {
   EXPECT_EQ(2u, endpoints.size());
   auto origin_1_endpoints = endpoints.at(kOrigin1_);
   EXPECT_EQ(2u, origin_1_endpoints.size());
-  EXPECT_EQ(ReportingEndpointGroupKey(network_isolation_key_1,
+  EXPECT_EQ(ReportingEndpointGroupKey(network_anonymization_key_1,
                                       *kReportingSource_, kOrigin1_, kGroup1_),
             origin_1_endpoints[0].group_key);
   EXPECT_EQ(kUrl1_, origin_1_endpoints[0].info.url);
-  EXPECT_EQ(ReportingEndpointGroupKey(network_isolation_key_1,
+  EXPECT_EQ(ReportingEndpointGroupKey(network_anonymization_key_1,
                                       *kReportingSource_, kOrigin1_, kGroup2_),
             origin_1_endpoints[1].group_key);
   EXPECT_EQ(kUrl2_, origin_1_endpoints[1].info.url);
   auto origin_2_endpoints = endpoints.at(kOrigin2_);
   EXPECT_EQ(1u, origin_2_endpoints.size());
-  EXPECT_EQ(ReportingEndpointGroupKey(network_isolation_key_2,
+  EXPECT_EQ(ReportingEndpointGroupKey(network_anonymization_key_2,
                                       reporting_source_2, kOrigin2_, kGroup1_),
             origin_2_endpoints[0].group_key);
   EXPECT_EQ(kUrl2_, origin_2_endpoints[0].info.url);
diff --git a/chromium/net/reporting/reporting_context.cc b/chromium/net/reporting/reporting_context.cc
index c33b42dda94..1867ac1c9e9 100644
--- a/chromium/net/reporting/reporting_context.cc
+++ b/chromium/net/reporting/reporting_context.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_context.h b/chromium/net/reporting/reporting_context.h
index 7ec3eb5f241..3f8eb962013 100644
--- a/chromium/net/reporting/reporting_context.h
+++ b/chromium/net/reporting/reporting_context.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_delegate.cc b/chromium/net/reporting/reporting_delegate.cc
index e2f676d4b6c..1b828cac578 100644
--- a/chromium/net/reporting/reporting_delegate.cc
+++ b/chromium/net/reporting/reporting_delegate.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_delegate.h b/chromium/net/reporting/reporting_delegate.h
index 1a2ff9e67eb..665f1c63e88 100644
--- a/chromium/net/reporting/reporting_delegate.h
+++ b/chromium/net/reporting/reporting_delegate.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_delivery_agent.cc b/chromium/net/reporting/reporting_delivery_agent.cc
index 149681a8949..529653bfdc5 100644
--- a/chromium/net/reporting/reporting_delivery_agent.cc
+++ b/chromium/net/reporting/reporting_delivery_agent.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -22,7 +22,7 @@
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/url_util.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_cache_observer.h"
@@ -57,7 +57,7 @@ std::string SerializeReports(const ReportList& reports, base::TimeTicks now) {
     report_value.Set("type", report->type);
     report_value.Set("url", report->url.spec());
     report_value.Set("user_agent", report->user_agent);
-    report_value.Set("body", report->body->Clone());
+    report_value.Set("body", report->body.Clone());
 
     reports_value.Append(std::move(report_value));
   }
@@ -86,23 +86,24 @@ class Delivery {
   // to the same endpoint URL.
   // |isolation_info| is the IsolationInfo struct associated with the reporting
   // endpoint, and is used to determine appropriate credentials for the upload.
-  // |network_isolation_key| is the NIK from the ReportingEndpoint, which may
-  // have been cleared in the ReportingService if reports are not being
+  // |network_anonymization_key| is the NIK from the ReportingEndpoint, which
+  // may have been cleared in the ReportingService if reports are not being
   // partitioned by NIK. (This is why a separate parameter is used here, rather
   // than simply using the computed NIK from |isolation_info|.)
   struct Target {
     Target(const IsolationInfo& isolation_info,
-           const NetworkIsolationKey& network_isolation_key,
+           const NetworkAnonymizationKey& network_anonymization_key,
            const url::Origin& origin,
            const GURL& endpoint_url,
            const absl::optional<base::UnguessableToken> reporting_source)
         : isolation_info(isolation_info),
-          network_isolation_key(network_isolation_key),
+          network_anonymization_key(network_anonymization_key),
           origin(origin),
           endpoint_url(endpoint_url),
           reporting_source(reporting_source) {
-      DCHECK(network_isolation_key.IsEmpty() ||
-             network_isolation_key == isolation_info.network_isolation_key());
+      DCHECK(network_anonymization_key.IsEmpty() ||
+             network_anonymization_key ==
+                 isolation_info.network_anonymization_key());
     }
 
     ~Target() = default;
@@ -111,14 +112,14 @@ class Delivery {
       // Note that sorting by NIK here is required for V0 reports; V1 reports
       // should not need this (but it doesn't hurt). We can remove that as a
       // comparison key when V0 reporting endpoints are removed.
-      return std::tie(network_isolation_key, origin, endpoint_url,
+      return std::tie(network_anonymization_key, origin, endpoint_url,
                       reporting_source) <
-             std::tie(other.network_isolation_key, other.origin,
+             std::tie(other.network_anonymization_key, other.origin,
                       other.endpoint_url, other.reporting_source);
     }
 
     IsolationInfo isolation_info;
-    NetworkIsolationKey network_isolation_key;
+    NetworkAnonymizationKey network_anonymization_key;
     url::Origin origin;
     GURL endpoint_url;
     absl::optional<base::UnguessableToken> reporting_source;
@@ -135,12 +136,13 @@ class Delivery {
                   const ReportList::const_iterator reports_begin,
                   const ReportList::const_iterator reports_end) {
     DCHECK(reports_begin != reports_end);
-    DCHECK(endpoint.group_key.network_isolation_key == network_isolation_key());
+    DCHECK(endpoint.group_key.network_anonymization_key ==
+           network_anonymization_key());
     DCHECK(IsSubdomainOf(target_.origin.host() /* subdomain */,
                          endpoint.group_key.origin.host() /* superdomain */));
     for (auto it = reports_begin; it != reports_end; ++it) {
       DCHECK_EQ((*reports_begin)->GetGroupKey(), (*it)->GetGroupKey());
-      DCHECK((*it)->network_isolation_key == network_isolation_key());
+      DCHECK((*it)->network_anonymization_key == network_anonymization_key());
       DCHECK_EQ(url::Origin::Create((*it)->url), target_.origin);
       DCHECK_EQ((*it)->group, endpoint.group_key.group_name);
       // Report origin is equal to, or a subdomain of, the endpoint
@@ -177,8 +179,8 @@ class Delivery {
     }
   }
 
-  const NetworkIsolationKey& network_isolation_key() const {
-    return target_.network_isolation_key;
+  const NetworkAnonymizationKey& network_anonymization_key() const {
+    return target_.network_anonymization_key;
   }
   const GURL& endpoint_url() const { return target_.endpoint_url; }
   const ReportList& reports() const { return reports_; }
@@ -321,7 +323,7 @@ class ReportingDeliveryAgentImpl : public ReportingDeliveryAgent,
 
       // Add the reports to the appropriate delivery.
       Delivery::Target target(isolation_info,
-                              report_group_key.network_isolation_key,
+                              report_group_key.network_anonymization_key,
                               report_group_key.origin, endpoint.info.url,
                               endpoint.group_key.reporting_source);
       auto delivery_it = deliveries.find(target);
@@ -373,7 +375,8 @@ class ReportingDeliveryAgentImpl : public ReportingDeliveryAgent,
     delivery->ProcessOutcome(cache(), success);
 
     endpoint_manager_->InformOfEndpointRequest(
-        delivery->network_isolation_key(), delivery->endpoint_url(), success);
+        delivery->network_anonymization_key(), delivery->endpoint_url(),
+        success);
 
     // TODO(chlily): This leaks information across NIKs. If the endpoint URL is
     // configured for both NIK1 and NIK2, and it responds with a 410 on a NIK1
diff --git a/chromium/net/reporting/reporting_delivery_agent.h b/chromium/net/reporting/reporting_delivery_agent.h
index 613219374e0..470be91c08a 100644
--- a/chromium/net/reporting/reporting_delivery_agent.h
+++ b/chromium/net/reporting/reporting_delivery_agent.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_delivery_agent_unittest.cc b/chromium/net/reporting/reporting_delivery_agent_unittest.cc
index 5042b35284f..14c0649feb7 100644
--- a/chromium/net/reporting/reporting_delivery_agent_unittest.cc
+++ b/chromium/net/reporting/reporting_delivery_agent_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -18,7 +18,7 @@
 #include "net/base/backoff_entry.h"
 #include "net/base/features.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_report.h"
@@ -56,12 +56,12 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
   }
 
   void AddReport(const absl::optional<base::UnguessableToken>& reporting_source,
-                 const NetworkIsolationKey& network_isolation_key,
+                 const NetworkAnonymizationKey& network_anonymization_key,
                  const GURL& url,
                  const std::string& group) {
     base::Value::Dict report_body;
     report_body.Set("key", "value");
-    cache()->AddReport(reporting_source, network_isolation_key, url,
+    cache()->AddReport(reporting_source, network_anonymization_key, url,
                        kUserAgent_, group, kType_, std::move(report_body),
                        0 /* depth */, tick_clock()->NowTicks() /* queued */,
                        0 /* attempts */);
@@ -73,11 +73,11 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
   // immediately resolve a dummy report to prime the delivery timer.
   void UploadFirstReportAndStartTimer() {
     ReportingEndpointGroupKey dummy_group(
-        NetworkIsolationKey(), url::Origin::Create(GURL("https://dummy.test")),
-        "dummy");
+        NetworkAnonymizationKey(),
+        url::Origin::Create(GURL("https://dummy.test")), "dummy");
     ASSERT_TRUE(SetEndpointInCache(
         dummy_group, GURL("https://dummy.test/upload"), kExpires_));
-    AddReport(absl::nullopt, dummy_group.network_isolation_key,
+    AddReport(absl::nullopt, dummy_group.network_anonymization_key,
               dummy_group.origin.GetURL(), dummy_group.group_name);
 
     ASSERT_EQ(1u, pending_uploads().size());
@@ -94,7 +94,7 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
         url::Origin::Create(GURL("https://dummy.test")), "dummy");
     SetV1EndpointInCache(dummy_group, kDocumentReportingSource_,
                          kIsolationInfo_, GURL("https://dummy.test/upload"));
-    AddReport(kDocumentReportingSource_, dummy_group.network_isolation_key,
+    AddReport(kDocumentReportingSource_, dummy_group.network_anonymization_key,
               dummy_group.origin.GetURL(), dummy_group.group_name);
 
     ASSERT_EQ(1u, pending_uploads().size());
@@ -119,11 +119,11 @@ class ReportingDeliveryAgentTest : public ReportingTestBase {
       absl::nullopt;
   const base::UnguessableToken kDocumentReportingSource_ =
       base::UnguessableToken::Create();
-  const NetworkIsolationKey kNik_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin_), SchemefulSite(kOrigin_));
-  const NetworkIsolationKey kOtherNik_ =
-      NetworkIsolationKey(SchemefulSite(kOtherOrigin_),
-                          SchemefulSite(kOtherOrigin_));
+  const NetworkAnonymizationKey kNik_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin_), SchemefulSite(kOrigin_));
+  const NetworkAnonymizationKey kOtherNik_ =
+      NetworkAnonymizationKey(SchemefulSite(kOtherOrigin_),
+                              SchemefulSite(kOtherOrigin_));
   const IsolationInfo kIsolationInfo_ =
       IsolationInfo::Create(IsolationInfo::RequestType::kOther,
                             kOrigin_,
diff --git a/chromium/net/reporting/reporting_endpoint.cc b/chromium/net/reporting/reporting_endpoint.cc
index 187c0c7db3d..1405aff51d7 100644
--- a/chromium/net/reporting/reporting_endpoint.cc
+++ b/chromium/net/reporting/reporting_endpoint.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -16,20 +16,20 @@ namespace net {
 ReportingEndpointGroupKey::ReportingEndpointGroupKey() = default;
 
 ReportingEndpointGroupKey::ReportingEndpointGroupKey(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin,
     const std::string& group_name)
-    : ReportingEndpointGroupKey(network_isolation_key,
+    : ReportingEndpointGroupKey(network_anonymization_key,
                                 absl::nullopt,
                                 origin,
                                 group_name) {}
 
 ReportingEndpointGroupKey::ReportingEndpointGroupKey(
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     absl::optional<base::UnguessableToken> reporting_source,
     const url::Origin& origin,
     const std::string& group_name)
-    : network_isolation_key(network_isolation_key),
+    : network_anonymization_key(network_anonymization_key),
       reporting_source(std::move(reporting_source)),
       origin(origin),
       group_name(group_name) {
@@ -41,7 +41,7 @@ ReportingEndpointGroupKey::ReportingEndpointGroupKey(
 ReportingEndpointGroupKey::ReportingEndpointGroupKey(
     const ReportingEndpointGroupKey& other,
     const absl::optional<base::UnguessableToken>& reporting_source)
-    : ReportingEndpointGroupKey(other.network_isolation_key,
+    : ReportingEndpointGroupKey(other.network_anonymization_key,
                                 reporting_source,
                                 other.origin,
                                 other.group_name) {}
@@ -60,10 +60,10 @@ ReportingEndpointGroupKey::~ReportingEndpointGroupKey() = default;
 
 bool operator==(const ReportingEndpointGroupKey& lhs,
                 const ReportingEndpointGroupKey& rhs) {
-  return std::tie(lhs.reporting_source, lhs.network_isolation_key, lhs.origin,
-                  lhs.group_name) == std::tie(rhs.reporting_source,
-                                              rhs.network_isolation_key,
-                                              rhs.origin, rhs.group_name);
+  return std::tie(lhs.reporting_source, lhs.network_anonymization_key,
+                  lhs.origin, lhs.group_name) ==
+         std::tie(rhs.reporting_source, rhs.network_anonymization_key,
+                  rhs.origin, rhs.group_name);
 }
 
 bool operator!=(const ReportingEndpointGroupKey& lhs,
@@ -73,24 +73,24 @@ bool operator!=(const ReportingEndpointGroupKey& lhs,
 
 bool operator<(const ReportingEndpointGroupKey& lhs,
                const ReportingEndpointGroupKey& rhs) {
-  return std::tie(lhs.reporting_source, lhs.network_isolation_key, lhs.origin,
-                  lhs.group_name) < std::tie(rhs.reporting_source,
-                                             rhs.network_isolation_key,
-                                             rhs.origin, rhs.group_name);
+  return std::tie(lhs.reporting_source, lhs.network_anonymization_key,
+                  lhs.origin, lhs.group_name) <
+         std::tie(rhs.reporting_source, rhs.network_anonymization_key,
+                  rhs.origin, rhs.group_name);
 }
 
 bool operator>(const ReportingEndpointGroupKey& lhs,
                const ReportingEndpointGroupKey& rhs) {
-  return std::tie(lhs.reporting_source, lhs.network_isolation_key, lhs.origin,
-                  lhs.group_name) > std::tie(rhs.reporting_source,
-                                             rhs.network_isolation_key,
-                                             rhs.origin, rhs.group_name);
+  return std::tie(lhs.reporting_source, lhs.network_anonymization_key,
+                  lhs.origin, lhs.group_name) >
+         std::tie(rhs.reporting_source, rhs.network_anonymization_key,
+                  rhs.origin, rhs.group_name);
 }
 
 std::string ReportingEndpointGroupKey::ToString() const {
   return "Source: " +
          (reporting_source ? reporting_source->ToString() : "null") +
-         "; NIK: " + network_isolation_key.ToDebugString() +
+         "; NIK: " + network_anonymization_key.ToDebugString() +
          "; Origin: " + origin.Serialize() + "; Group name: " + group_name;
 }
 
diff --git a/chromium/net/reporting/reporting_endpoint.h b/chromium/net/reporting/reporting_endpoint.h
index ef5e3901cd5..1b99c0c83dc 100644
--- a/chromium/net/reporting/reporting_endpoint.h
+++ b/chromium/net/reporting/reporting_endpoint.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -11,7 +11,7 @@
 #include "base/time/time.h"
 #include "base/unguessable_token.h"
 #include "net/base/net_export.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ -22,12 +22,13 @@ namespace net {
 struct NET_EXPORT ReportingEndpointGroupKey {
   ReportingEndpointGroupKey();
 
-  ReportingEndpointGroupKey(const NetworkIsolationKey& network_isolation_key,
-                            const url::Origin& origin,
-                            const std::string& group_name);
+  ReportingEndpointGroupKey(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const url::Origin& origin,
+      const std::string& group_name);
 
   ReportingEndpointGroupKey(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       absl::optional<base::UnguessableToken> reporting_source,
       const url::Origin& origin,
       const std::string& group_name);
@@ -50,9 +51,9 @@ struct NET_EXPORT ReportingEndpointGroupKey {
   // V1 document endpoint.
   bool IsDocumentEndpoint() const { return reporting_source.has_value(); }
 
-  // The NetworkIsolationKey the group is scoped to. Needed to prevent leaking
-  // third party contexts across sites.
-  NetworkIsolationKey network_isolation_key;
+  // The NetworkAnonymizationKey the group is scoped to. Needed to prevent
+  // leaking third party contexts across sites.
+  NetworkAnonymizationKey network_anonymization_key;
 
   // Source token for the document or worker which configured this endpoint, if
   // this was configured with the Reporting-Endpoints header. For endpoint
diff --git a/chromium/net/reporting/reporting_endpoint_manager.cc b/chromium/net/reporting/reporting_endpoint_manager.cc
index 12a2a549cfd..46d48b96e85 100644
--- a/chromium/net/reporting/reporting_endpoint_manager.cc
+++ b/chromium/net/reporting/reporting_endpoint_manager.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -17,7 +17,7 @@
 #include "base/rand_util.h"
 #include "base/time/tick_clock.h"
 #include "net/base/backoff_entry.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/rand_callback.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_delegate.h"
@@ -83,7 +83,7 @@ class ReportingEndpointManagerImpl : public ReportingEndpointManager {
       // This brings each match to the front of the MRU cache, so if an entry
       // frequently matches requests, it's more likely to stay in the cache.
       auto endpoint_backoff_it = endpoint_backoff_.Get(EndpointBackoffKey(
-          group_key.network_isolation_key, endpoint.info.url));
+          group_key.network_anonymization_key, endpoint.info.url));
       if (endpoint_backoff_it != endpoint_backoff_.end() &&
           endpoint_backoff_it->second->ShouldRejectRequest()) {
         continue;
@@ -124,10 +124,12 @@ class ReportingEndpointManagerImpl : public ReportingEndpointManager {
     return ReportingEndpoint();
   }
 
-  void InformOfEndpointRequest(const NetworkIsolationKey& network_isolation_key,
-                               const GURL& endpoint,
-                               bool succeeded) override {
-    EndpointBackoffKey endpoint_backoff_key(network_isolation_key, endpoint);
+  void InformOfEndpointRequest(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const GURL& endpoint,
+      bool succeeded) override {
+    EndpointBackoffKey endpoint_backoff_key(network_anonymization_key,
+                                            endpoint);
     // This will bring the entry to the front of the cache, if it exists.
     auto endpoint_backoff_it = endpoint_backoff_.Get(endpoint_backoff_key);
     if (endpoint_backoff_it == endpoint_backoff_.end()) {
@@ -140,7 +142,7 @@ class ReportingEndpointManagerImpl : public ReportingEndpointManager {
   }
 
  private:
-  using EndpointBackoffKey = std::pair<NetworkIsolationKey, GURL>;
+  using EndpointBackoffKey = std::pair<NetworkAnonymizationKey, GURL>;
 
   const raw_ptr<const ReportingPolicy> policy_;
   const raw_ptr<const base::TickClock> tick_clock_;
diff --git a/chromium/net/reporting/reporting_endpoint_manager.h b/chromium/net/reporting/reporting_endpoint_manager.h
index 1a23771081f..c6e6eea82bb 100644
--- a/chromium/net/reporting/reporting_endpoint_manager.h
+++ b/chromium/net/reporting/reporting_endpoint_manager.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -19,7 +19,7 @@ class TickClock;
 
 namespace net {
 
-class NetworkIsolationKey;
+class NetworkAnonymizationKey;
 class ReportingCache;
 class ReportingDelegate;
 struct ReportingEndpoint;
@@ -59,7 +59,7 @@ class NET_EXPORT ReportingEndpointManager {
   // Informs the EndpointManager of a successful or unsuccessful request made to
   // |endpoint| so it can manage exponential backoff of failing endpoints.
   virtual void InformOfEndpointRequest(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const GURL& endpoint,
       bool succeeded) = 0;
 };
diff --git a/chromium/net/reporting/reporting_endpoint_manager_unittest.cc b/chromium/net/reporting/reporting_endpoint_manager_unittest.cc
index 67d2d5a4ee8..02c8d9fa553 100644
--- a/chromium/net/reporting/reporting_endpoint_manager_unittest.cc
+++ b/chromium/net/reporting/reporting_endpoint_manager_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -12,7 +12,7 @@
 #include "base/unguessable_token.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_endpoint.h"
@@ -41,7 +41,7 @@ class TestReportingCache : public ReportingCache {
   ~TestReportingCache() override = default;
 
   void SetEndpoint(const ReportingEndpoint& reporting_endpoint) {
-    reporting_endpoints_[reporting_endpoint.group_key.network_isolation_key]
+    reporting_endpoints_[reporting_endpoint.group_key.network_anonymization_key]
         .push_back(reporting_endpoint);
   }
 
@@ -51,12 +51,12 @@ class TestReportingCache : public ReportingCache {
       const ReportingEndpointGroupKey& group_key) override {
     EXPECT_EQ(expected_origin_, group_key.origin);
     EXPECT_EQ(expected_group_, group_key.group_name);
-    return reporting_endpoints_[group_key.network_isolation_key];
+    return reporting_endpoints_[group_key.network_anonymization_key];
   }
 
   // Everything below is NOTREACHED.
   void AddReport(const absl::optional<base::UnguessableToken>& reporting_source,
-                 const NetworkIsolationKey& network_isolation_key,
+                 const NetworkAnonymizationKey& network_anonymization_key,
                  const GURL& url,
                  const std::string& user_agent,
                  const std::string& group_name,
@@ -139,7 +139,7 @@ class TestReportingCache : public ReportingCache {
     return false;
   }
   void OnParsedHeader(
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       std::vector<ReportingEndpointGroup> parsed_header) override {
     NOTREACHED();
@@ -154,7 +154,7 @@ class TestReportingCache : public ReportingCache {
     NOTREACHED();
     return std::set<url::Origin>();
   }
-  void RemoveClient(const NetworkIsolationKey& network_isolation_key,
+  void RemoveClient(const NetworkAnonymizationKey& network_anonymization_key,
                     const url::Origin& origin) override {
     NOTREACHED();
   }
@@ -204,8 +204,9 @@ class TestReportingCache : public ReportingCache {
     NOTREACHED();
     return false;
   }
-  bool ClientExistsForTesting(const NetworkIsolationKey& network_isolation_key,
-                              const url::Origin& origin) const override {
+  bool ClientExistsForTesting(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const url::Origin& origin) const override {
     NOTREACHED();
     return false;
   }
@@ -245,7 +246,7 @@ class TestReportingCache : public ReportingCache {
   const url::Origin expected_origin_;
   const std::string expected_group_;
 
-  std::map<NetworkIsolationKey, std::vector<ReportingEndpoint>>
+  std::map<NetworkAnonymizationKey, std::vector<ReportingEndpoint>>
       reporting_endpoints_;
   base::flat_set<base::UnguessableToken> expired_sources_;
 };
@@ -272,16 +273,16 @@ class ReportingEndpointManagerTest : public testing::Test {
       const GURL& endpoint,
       int priority = ReportingEndpoint::EndpointInfo::kDefaultPriority,
       int weight = ReportingEndpoint::EndpointInfo::kDefaultWeight,
-      const NetworkIsolationKey& network_isolation_key =
-          NetworkIsolationKey()) {
+      const NetworkAnonymizationKey& network_anonymization_key =
+          NetworkAnonymizationKey()) {
     ReportingEndpointGroupKey group_key(kGroupKey);
-    group_key.network_isolation_key = network_isolation_key;
+    group_key.network_anonymization_key = network_anonymization_key;
     cache_.SetEndpoint(ReportingEndpoint(
         group_key,
         ReportingEndpoint::EndpointInfo{endpoint, priority, weight}));
   }
 
-  const NetworkIsolationKey kNik;
+  const NetworkAnonymizationKey kNik;
   const url::Origin kOrigin = url::Origin::Create(GURL("https://origin/"));
   const SchemefulSite kSite = SchemefulSite(kOrigin);
   const std::string kGroup = "group";
@@ -319,8 +320,8 @@ TEST_F(ReportingEndpointManagerTest, BackedOffEndpoint) {
 
   SetEndpoint(kEndpoint);
 
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(), kEndpoint,
-                                             false);
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
+                                             kEndpoint, false);
 
   // After one failure, endpoint is in exponential backoff.
   ReportingEndpoint endpoint =
@@ -335,8 +336,8 @@ TEST_F(ReportingEndpointManagerTest, BackedOffEndpoint) {
   ASSERT_TRUE(endpoint2);
   EXPECT_EQ(kEndpoint, endpoint2.info.url);
 
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(), kEndpoint,
-                                             false);
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
+                                             kEndpoint, false);
 
   // After a second failure, endpoint is backed off again.
   ReportingEndpoint endpoint3 =
@@ -358,15 +359,15 @@ TEST_F(ReportingEndpointManagerTest, BackedOffEndpoint) {
   ASSERT_TRUE(endpoint5);
   EXPECT_EQ(kEndpoint, endpoint5.info.url);
 
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(), kEndpoint,
-                                             true);
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(), kEndpoint,
-                                             true);
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
+                                             kEndpoint, true);
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
+                                             kEndpoint, true);
 
   // Two more successful requests should reset the backoff to the initial delay
   // again.
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(), kEndpoint,
-                                             false);
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
+                                             kEndpoint, false);
 
   ReportingEndpoint endpoint6 =
       endpoint_manager_->FindEndpointForDelivery(kGroupKey);
@@ -429,7 +430,7 @@ TEST_F(ReportingEndpointManagerTest, Priority) {
   // The backoff policy we set up in the constructor means that a single failed
   // upload will take the primary endpoint out of contention.  This should cause
   // us to choose the backend endpoint.
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(),
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
                                              kPrimaryEndpoint, false);
   ReportingEndpoint endpoint2 =
       endpoint_manager_->FindEndpointForDelivery(kGroupKey);
@@ -510,21 +511,21 @@ TEST_F(ReportingEndpointManagerTest, ZeroWeights) {
   EXPECT_EQ(5, endpoint2_count);
 }
 
-// Check that ReportingEndpointManager distinguishes NetworkIsolationKeys.
-TEST_F(ReportingEndpointManagerTest, NetworkIsolationKey) {
+// Check that ReportingEndpointManager distinguishes NetworkAnonymizationKeys.
+TEST_F(ReportingEndpointManagerTest, NetworkAnonymizationKey) {
   const SchemefulSite kSite2(GURL("https://origin2/"));
 
-  const NetworkIsolationKey kNetworkIsolationKey1(kSite, kSite);
-  const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
-  const ReportingEndpointGroupKey kGroupKey1(kNetworkIsolationKey1, kOrigin,
+  const NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite, kSite);
+  const NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2);
+  const ReportingEndpointGroupKey kGroupKey1(kNetworkAnonymizationKey1, kOrigin,
                                              kGroup);
-  const ReportingEndpointGroupKey kGroupKey2(kNetworkIsolationKey2, kOrigin,
+  const ReportingEndpointGroupKey kGroupKey2(kNetworkAnonymizationKey2, kOrigin,
                                              kGroup);
 
-  // An Endpoint set for kNetworkIsolationKey1 should not affect
-  // kNetworkIsolationKey2.
+  // An Endpoint set for kNetworkAnonymizationKey1 should not affect
+  // kNetworkAnonymizationKey2.
   SetEndpoint(kEndpoint, ReportingEndpoint::EndpointInfo::kDefaultPriority,
-              0 /* weight */, kNetworkIsolationKey1);
+              0 /* weight */, kNetworkAnonymizationKey1);
   ReportingEndpoint endpoint =
       endpoint_manager_->FindEndpointForDelivery(kGroupKey1);
   ASSERT_TRUE(endpoint);
@@ -532,10 +533,10 @@ TEST_F(ReportingEndpointManagerTest, NetworkIsolationKey) {
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey2));
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey));
 
-  // Set the same Endpoint for kNetworkIsolationKey2, so both should be
+  // Set the same Endpoint for kNetworkAnonymizationKey2, so both should be
   // reporting to the same URL.
   SetEndpoint(kEndpoint, ReportingEndpoint::EndpointInfo::kDefaultPriority,
-              0 /* weight */, kNetworkIsolationKey2);
+              0 /* weight */, kNetworkAnonymizationKey2);
   endpoint = endpoint_manager_->FindEndpointForDelivery(kGroupKey1);
   ASSERT_TRUE(endpoint);
   EXPECT_EQ(kEndpoint, endpoint.info.url);
@@ -544,11 +545,11 @@ TEST_F(ReportingEndpointManagerTest, NetworkIsolationKey) {
   EXPECT_EQ(kEndpoint, endpoint.info.url);
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey));
 
-  // An error reporting to that URL in the context of kNetworkIsolationKey1
+  // An error reporting to that URL in the context of kNetworkAnonymizationKey1
   // should only affect the Endpoint retrieved in the context of
-  // kNetworkIsolationKey1.
-  endpoint_manager_->InformOfEndpointRequest(kNetworkIsolationKey1, kEndpoint,
-                                             false);
+  // kNetworkAnonymizationKey1.
+  endpoint_manager_->InformOfEndpointRequest(kNetworkAnonymizationKey1,
+                                             kEndpoint, false);
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey1));
   endpoint = endpoint_manager_->FindEndpointForDelivery(kGroupKey2);
   ASSERT_TRUE(endpoint);
@@ -556,14 +557,15 @@ TEST_F(ReportingEndpointManagerTest, NetworkIsolationKey) {
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey));
 }
 
-TEST_F(ReportingEndpointManagerTest, NetworkIsolationKeyWithMultipleEndpoints) {
+TEST_F(ReportingEndpointManagerTest,
+       NetworkAnonymizationKeyWithMultipleEndpoints) {
   const SchemefulSite kSite2(GURL("https://origin2/"));
 
-  const NetworkIsolationKey kNetworkIsolationKey1(kSite, kSite);
-  const NetworkIsolationKey kNetworkIsolationKey2(kSite2, kSite2);
-  const ReportingEndpointGroupKey kGroupKey1(kNetworkIsolationKey1, kOrigin,
+  const NetworkAnonymizationKey kNetworkAnonymizationKey1(kSite, kSite);
+  const NetworkAnonymizationKey kNetworkAnonymizationKey2(kSite2, kSite2);
+  const ReportingEndpointGroupKey kGroupKey1(kNetworkAnonymizationKey1, kOrigin,
                                              kGroup);
-  const ReportingEndpointGroupKey kGroupKey2(kNetworkIsolationKey2, kOrigin,
+  const ReportingEndpointGroupKey kGroupKey2(kNetworkAnonymizationKey2, kOrigin,
                                              kGroup);
 
   const GURL kEndpoint1("https://endpoint1/");
@@ -571,23 +573,24 @@ TEST_F(ReportingEndpointManagerTest, NetworkIsolationKeyWithMultipleEndpoints) {
   const GURL kEndpoint3("https://endpoint3/");
   const int kMaxAttempts = 20;
 
-  // Add two Endpoints for kNetworkIsolationKey1, and a different one for
-  // kNetworkIsolationKey2.
+  // Add two Endpoints for kNetworkAnonymizationKey1, and a different one for
+  // kNetworkAnonymizationKey2.
   SetEndpoint(kEndpoint1, ReportingEndpoint::EndpointInfo::kDefaultPriority,
               ReportingEndpoint::EndpointInfo::kDefaultWeight,
-              kNetworkIsolationKey1);
+              kNetworkAnonymizationKey1);
   SetEndpoint(kEndpoint2, ReportingEndpoint::EndpointInfo::kDefaultPriority,
               ReportingEndpoint::EndpointInfo::kDefaultWeight,
-              kNetworkIsolationKey1);
+              kNetworkAnonymizationKey1);
   SetEndpoint(kEndpoint3, ReportingEndpoint::EndpointInfo::kDefaultPriority,
               ReportingEndpoint::EndpointInfo::kDefaultWeight,
-              kNetworkIsolationKey2);
+              kNetworkAnonymizationKey2);
 
   bool endpoint1_seen = false;
   bool endpoint2_seen = false;
 
-  // Make sure that calling FindEndpointForDelivery() with kNetworkIsolationKey1
-  // can return both of its endpoints, but not kNetworkIsolationKey2's endpoint.
+  // Make sure that calling FindEndpointForDelivery() with
+  // kNetworkAnonymizationKey1 can return both of its endpoints, but not
+  // kNetworkAnonymizationKey2's endpoint.
   for (int i = 0; i < kMaxAttempts; ++i) {
     ReportingEndpoint endpoint =
         endpoint_manager_->FindEndpointForDelivery(kGroupKey1);
@@ -629,40 +632,40 @@ TEST_F(ReportingEndpointManagerTest, CacheEviction) {
     EXPECT_TRUE(endpoint);
     EXPECT_FALSE(seen_endpoints.count(endpoint.info.url));
     seen_endpoints.insert(endpoint.info.url);
-    endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(),
+    endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
                                                endpoint.info.url, false);
   }
   // All endpoints should now be marked as bad.
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey));
 
-  // Add another endpoint with a different NetworkIsolationKey;
-  const NetworkIsolationKey kDifferentNetworkIsolationKey(kSite, kSite);
+  // Add another endpoint with a different NetworkAnonymizationKey;
+  const NetworkAnonymizationKey kDifferentNetworkAnonymizationKey(kSite, kSite);
   const ReportingEndpointGroupKey kDifferentGroupKey(
-      kDifferentNetworkIsolationKey, kOrigin, kGroup);
+      kDifferentNetworkAnonymizationKey, kOrigin, kGroup);
   SetEndpoint(kEndpoint, ReportingEndpoint::EndpointInfo::kDefaultPriority,
               ReportingEndpoint::EndpointInfo::kDefaultWeight,
-              kDifferentNetworkIsolationKey);
-  // All endpoints associated with the empty NetworkIsolationKey should still be
-  // marked as bad.
+              kDifferentNetworkAnonymizationKey);
+  // All endpoints associated with the empty NetworkAnonymizationKey should
+  // still be marked as bad.
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kGroupKey));
 
-  // Make the endpoint added for the kDifferentNetworkIsolationKey as bad.
-  endpoint_manager_->InformOfEndpointRequest(kDifferentNetworkIsolationKey,
+  // Make the endpoint added for the kDifferentNetworkAnonymizationKey as bad.
+  endpoint_manager_->InformOfEndpointRequest(kDifferentNetworkAnonymizationKey,
                                              kEndpoint, false);
-  // The only endpoint for kDifferentNetworkIsolationKey should still be marked
-  // as bad.
+  // The only endpoint for kDifferentNetworkAnonymizationKey should still be
+  // marked as bad.
   EXPECT_FALSE(endpoint_manager_->FindEndpointForDelivery(kDifferentGroupKey));
-  // One of the endpoints for the empty NetworkIsolationKey should no longer be
-  // marked as bad, due to eviction.
+  // One of the endpoints for the empty NetworkAnonymizationKey should no longer
+  // be marked as bad, due to eviction.
   ReportingEndpoint endpoint =
       endpoint_manager_->FindEndpointForDelivery(kGroupKey);
   EXPECT_TRUE(endpoint);
 
   // Reporting a success for the (only) good endpoint for the empty
-  // NetworkIsolationKey should evict the entry for kNetworkIsolationKey, since
-  // the most recent FindEndpointForDelivery() call visited all of the empty
-  // NetworkIsolationKey's cached bad entries.
-  endpoint_manager_->InformOfEndpointRequest(NetworkIsolationKey(),
+  // NetworkAnonymizationKey should evict the entry for
+  // kNetworkAnonymizationKey, since the most recent FindEndpointForDelivery()
+  // call visited all of the empty NetworkAnonymizationKey's cached bad entries.
+  endpoint_manager_->InformOfEndpointRequest(NetworkAnonymizationKey(),
                                              endpoint.info.url, true);
 
   EXPECT_TRUE(endpoint_manager_->FindEndpointForDelivery(kDifferentGroupKey));
diff --git a/chromium/net/reporting/reporting_garbage_collector.cc b/chromium/net/reporting/reporting_garbage_collector.cc
index b7b3809de6a..4db08e04f9e 100644
--- a/chromium/net/reporting/reporting_garbage_collector.cc
+++ b/chromium/net/reporting/reporting_garbage_collector.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_garbage_collector.h b/chromium/net/reporting/reporting_garbage_collector.h
index b56d4d512fc..3a658902a3c 100644
--- a/chromium/net/reporting/reporting_garbage_collector.h
+++ b/chromium/net/reporting/reporting_garbage_collector.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_garbage_collector_unittest.cc b/chromium/net/reporting/reporting_garbage_collector_unittest.cc
index 6f4cf28af2f..baeb01a5a18 100644
--- a/chromium/net/reporting/reporting_garbage_collector_unittest.cc
+++ b/chromium/net/reporting/reporting_garbage_collector_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -10,7 +10,7 @@
 #include "base/time/time.h"
 #include "base/timer/mock_timer.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_policy.h"
 #include "net/reporting/reporting_report.h"
@@ -31,7 +31,7 @@ class ReportingGarbageCollectorTest : public ReportingTestBase {
 
   const absl::optional<base::UnguessableToken> kReportingSource_ =
       base::UnguessableToken::Create();
-  const NetworkIsolationKey kNik_;
+  const NetworkAnonymizationKey kNik_;
   const IsolationInfo kIsolationInfo_;
   const GURL kUrl_ = GURL("https://origin/path");
   const std::string kUserAgent_ = "Mozilla/1.0";
diff --git a/chromium/net/reporting/reporting_header_parser.cc b/chromium/net/reporting/reporting_header_parser.cc
index 1dfd5e6d8a8..9bc7d46e766 100644
--- a/chromium/net/reporting/reporting_header_parser.cc
+++ b/chromium/net/reporting/reporting_header_parser.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -18,7 +18,7 @@
 #include "base/values.h"
 #include "net/base/features.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_context.h"
@@ -118,12 +118,13 @@ bool ProcessEndpoint(ReportingDelegate* delegate,
 // |value| is the parsed JSON value of the endpoint group tuple.
 // Returns true on successfully adding a non-empty group, or false if endpoint
 // group was discarded or processed as a deletion.
-bool ProcessEndpointGroup(ReportingDelegate* delegate,
-                          ReportingCache* cache,
-                          const NetworkIsolationKey& network_isolation_key,
-                          const url::Origin& origin,
-                          const base::Value& value,
-                          ReportingEndpointGroup* parsed_endpoint_group_out) {
+bool ProcessEndpointGroup(
+    ReportingDelegate* delegate,
+    ReportingCache* cache,
+    const NetworkAnonymizationKey& network_anonymization_key,
+    const url::Origin& origin,
+    const base::Value& value,
+    ReportingEndpointGroup* parsed_endpoint_group_out) {
   const base::Value::Dict* dict = value.GetIfDict();
   if (!dict)
     return false;
@@ -134,7 +135,7 @@ bool ProcessEndpointGroup(ReportingDelegate* delegate,
       return false;
     group_name = maybe_group_name->GetString();
   }
-  ReportingEndpointGroupKey group_key(network_isolation_key, origin,
+  ReportingEndpointGroupKey group_key(network_anonymization_key, origin,
                                       group_name);
   parsed_endpoint_group_out->group_key = group_key;
 
@@ -216,14 +217,14 @@ bool ProcessEndpoint(ReportingDelegate* delegate,
 bool ProcessV1Endpoint(ReportingDelegate* delegate,
                        ReportingCache* cache,
                        const base::UnguessableToken& reporting_source,
-                       const NetworkIsolationKey& network_isolation_key,
+                       const NetworkAnonymizationKey& network_anonymization_key,
                        const url::Origin& origin,
                        const std::string& endpoint_name,
                        const std::string& endpoint_url_string,
                        ReportingEndpoint& parsed_endpoint_out) {
   DCHECK(!reporting_source.is_empty());
-  ReportingEndpointGroupKey group_key(network_isolation_key, reporting_source,
-                                      origin, endpoint_name);
+  ReportingEndpointGroupKey group_key(network_anonymization_key,
+                                      reporting_source, origin, endpoint_name);
   parsed_endpoint_out.group_key = group_key;
 
   ReportingEndpoint::EndpointInfo parsed_endpoint;
@@ -276,7 +277,7 @@ void ReportingHeaderParser::RecordReportingHeaderType(
 // static
 void ReportingHeaderParser::ParseReportToHeader(
     ReportingContext* context,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin,
     const base::Value::List& list) {
   DCHECK(GURL::SchemeIsCryptographic(origin.scheme()));
@@ -288,7 +289,7 @@ void ReportingHeaderParser::ParseReportToHeader(
 
   for (const auto& group_value : list) {
     ReportingEndpointGroup parsed_endpoint_group;
-    if (ProcessEndpointGroup(delegate, cache, network_isolation_key, origin,
+    if (ProcessEndpointGroup(delegate, cache, network_anonymization_key, origin,
                              group_value, &parsed_endpoint_group)) {
       parsed_header.push_back(std::move(parsed_endpoint_group));
     }
@@ -300,13 +301,13 @@ void ReportingHeaderParser::ParseReportToHeader(
 
   // Remove the client if it has no valid endpoint groups.
   if (parsed_header.empty()) {
-    cache->RemoveClient(network_isolation_key, origin);
+    cache->RemoveClient(network_anonymization_key, origin);
     return;
   }
 
   RecordReportingHeaderType(ReportingHeaderType::kReportTo);
 
-  cache->OnParsedHeader(network_isolation_key, origin,
+  cache->OnParsedHeader(network_anonymization_key, origin,
                         std::move(parsed_header));
 }
 
@@ -315,14 +316,15 @@ void ReportingHeaderParser::ProcessParsedReportingEndpointsHeader(
     ReportingContext* context,
     const base::UnguessableToken& reporting_source,
     const IsolationInfo& isolation_info,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const url::Origin& origin,
     base::flat_map<std::string, std::string> header) {
   DCHECK(base::FeatureList::IsEnabled(net::features::kDocumentReporting));
   DCHECK(GURL::SchemeIsCryptographic(origin.scheme()));
   DCHECK(!reporting_source.is_empty());
-  DCHECK(network_isolation_key.IsEmpty() ||
-         network_isolation_key == isolation_info.network_isolation_key());
+  DCHECK(network_anonymization_key.IsEmpty() ||
+         network_anonymization_key ==
+             isolation_info.network_anonymization_key());
 
   ReportingDelegate* delegate = context->delegate();
   ReportingCache* cache = context->cache();
@@ -332,7 +334,7 @@ void ReportingHeaderParser::ProcessParsedReportingEndpointsHeader(
   for (const auto& member : header) {
     ReportingEndpoint parsed_endpoint;
     if (ProcessV1Endpoint(delegate, cache, reporting_source,
-                          network_isolation_key, origin, member.first,
+                          network_anonymization_key, origin, member.first,
                           member.second, parsed_endpoint)) {
       parsed_header.push_back(std::move(parsed_endpoint));
     }
diff --git a/chromium/net/reporting/reporting_header_parser.h b/chromium/net/reporting/reporting_header_parser.h
index f2cb81598d7..98b1cc8ab9d 100644
--- a/chromium/net/reporting/reporting_header_parser.h
+++ b/chromium/net/reporting/reporting_header_parser.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -18,7 +18,7 @@
 namespace net {
 
 class IsolationInfo;
-class NetworkIsolationKey;
+class NetworkAnonymizationKey;
 class ReportingContext;
 
 // Tries to parse a Reporting-Endpoints header. Returns base::nullopt if parsing
@@ -48,12 +48,12 @@ class NET_EXPORT ReportingHeaderParser {
 
   static void ParseReportToHeader(
       ReportingContext* context,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       const base::Value::List& list);
 
   // `isolation_info` here will be stored in the cache, associated with the
-  // `reporting_source`. `network_isolation_key` is the NIK which will be
+  // `reporting_source`. `network_anonymization_key` is the NIK which will be
   // passed in with reports to be queued. This must match the NIK from
   // `isolation_source`, unless it is empty (which will be the case if the
   // kPartitionNelAndReportingByNetworkIsolationKey feature is disabled.)
@@ -61,7 +61,7 @@ class NET_EXPORT ReportingHeaderParser {
       ReportingContext* context,
       const base::UnguessableToken& reporting_source,
       const IsolationInfo& isolation_info,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       base::flat_map<std::string, std::string> parsed_header);
 
diff --git a/chromium/net/reporting/reporting_header_parser_fuzzer.cc b/chromium/net/reporting/reporting_header_parser_fuzzer.cc
index 1b7ece7cd1d..b8e728e4517 100644
--- a/chromium/net/reporting/reporting_header_parser_fuzzer.cc
+++ b/chromium/net/reporting/reporting_header_parser_fuzzer.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -10,7 +10,7 @@
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_header_parser.h"
 #include "net/reporting/reporting_policy.pb.h"
@@ -42,7 +42,7 @@ void FuzzReportingHeaderParser(const std::string& data_json,
   // TODO: consider including proto definition for URL after moving that to
   // testing/libfuzzer/proto and creating a separate converter.
   net::ReportingHeaderParser::ParseReportToHeader(
-      &context, net::NetworkIsolationKey(),
+      &context, net::NetworkAnonymizationKey(),
       url::Origin::Create(GURL("https://origin/")), data_value->GetList());
   if (context.cache()->GetEndpointCount() == 0) {
     return;
diff --git a/chromium/net/reporting/reporting_header_parser_unittest.cc b/chromium/net/reporting/reporting_header_parser_unittest.cc
index 80260ea7f6e..3d617e7d3b0 100644
--- a/chromium/net/reporting/reporting_header_parser_unittest.cc
+++ b/chromium/net/reporting/reporting_header_parser_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -72,10 +72,12 @@ class ReportingHeaderParserTestBase
   const url::Origin kOrigin1_ = url::Origin::Create(kUrl1_);
   const GURL kUrl2_ = GURL("https://origin2.test/path");
   const url::Origin kOrigin2_ = url::Origin::Create(kUrl2_);
-  const NetworkIsolationKey kNik_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin1_), SchemefulSite(kOrigin1_));
-  const NetworkIsolationKey kOtherNik_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin2_), SchemefulSite(kOrigin2_));
+  const NetworkAnonymizationKey kNik_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin1_),
+                              SchemefulSite(kOrigin1_));
+  const NetworkAnonymizationKey kOtherNik_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin2_),
+                              SchemefulSite(kOrigin2_));
   const IsolationInfo kIsolationInfo_ =
       IsolationInfo::Create(IsolationInfo::RequestType::kOther,
                             kOrigin1_,
@@ -184,14 +186,14 @@ class ReportingHeaderParserTest : public ReportingHeaderParserTestBase {
     return s.str();
   }
 
-  void ParseHeader(const NetworkIsolationKey& network_isolation_key,
+  void ParseHeader(const NetworkAnonymizationKey& network_anonymization_key,
                    const url::Origin& origin,
                    const std::string& json) {
     absl::optional<base::Value> value =
         base::JSONReader::Read("[" + json + "]");
     if (value) {
       ReportingHeaderParser::ParseReportToHeader(
-          context(), network_isolation_key, origin, value->GetList());
+          context(), network_anonymization_key, origin, value->GetList());
     }
   }
 };
@@ -785,7 +787,7 @@ TEST_P(ReportingHeaderParserTest, EndpointGroupKey) {
       ReportingEndpointGroupKey(kOtherNik_, kOrigin2_, kGroup2_);
 
   const struct {
-    NetworkIsolationKey network_isolation_key;
+    NetworkAnonymizationKey network_anonymization_key;
     GURL url;
     ReportingEndpointGroupKey group1_key;
     ReportingEndpointGroupKey group2_key;
@@ -813,8 +815,8 @@ TEST_P(ReportingHeaderParserTest, EndpointGroupKey) {
     EXPECT_FALSE(EndpointGroupExistsInCache(source.group2_key,
                                             OriginSubdomains::DEFAULT));
 
-    ParseHeader(source.network_isolation_key, url::Origin::Create(source.url),
-                header1);
+    ParseHeader(source.network_anonymization_key,
+                url::Origin::Create(source.url), header1);
     endpoint_group_count += 2u;
     endpoint_count += 4u;
     EXPECT_EQ(endpoint_group_count, cache()->GetEndpointGroupCountForTesting());
@@ -864,7 +866,7 @@ TEST_P(ReportingHeaderParserTest, EndpointGroupKey) {
     EXPECT_TRUE(EndpointGroupExistsInCache(source.group2_key,
                                            OriginSubdomains::DEFAULT));
     EXPECT_TRUE(cache()->ClientExistsForTesting(
-        source.network_isolation_key, url::Origin::Create(source.url)));
+        source.network_anonymization_key, url::Origin::Create(source.url)));
   }
 
   // Test updating existing configurations
@@ -891,8 +893,8 @@ TEST_P(ReportingHeaderParserTest, EndpointGroupKey) {
               endpoint.info.priority);
     EXPECT_FALSE(FindEndpointInCache(source.group2_key, kEndpoint3_));
 
-    ParseHeader(source.network_isolation_key, url::Origin::Create(source.url),
-                header2);
+    ParseHeader(source.network_anonymization_key,
+                url::Origin::Create(source.url), header2);
     endpoint_group_count--;
     endpoint_count -= 2;
     EXPECT_EQ(endpoint_group_count, cache()->GetEndpointGroupCountForTesting());
@@ -948,7 +950,7 @@ TEST_P(ReportingHeaderParserTest, EndpointGroupKey) {
     EXPECT_TRUE(EndpointGroupExistsInCache(source.group2_key,
                                            OriginSubdomains::INCLUDE));
     EXPECT_TRUE(cache()->ClientExistsForTesting(
-        source.network_isolation_key, url::Origin::Create(source.url)));
+        source.network_anonymization_key, url::Origin::Create(source.url)));
   }
 }
 
@@ -1789,7 +1791,7 @@ class ReportingHeaderParserStructuredHeaderTest
     if (header_map) {
       ReportingHeaderParser::ProcessParsedReportingEndpointsHeader(
           context(), reporting_source, isolation_info,
-          isolation_info.network_isolation_key(), origin, *header_map);
+          isolation_info.network_anonymization_key(), origin, *header_map);
     }
   }
   void ProcessParsedHeader(
@@ -1800,7 +1802,7 @@ class ReportingHeaderParserStructuredHeaderTest
           header_map) {
     ReportingHeaderParser::ProcessParsedReportingEndpointsHeader(
         context(), reporting_source, isolation_info,
-        isolation_info.network_isolation_key(), origin, *header_map);
+        isolation_info.network_anonymization_key(), origin, *header_map);
   }
 
   const base::UnguessableToken kReportingSource_ =
@@ -1897,7 +1899,6 @@ TEST_P(ReportingHeaderParserStructuredHeaderTest, Basic) {
 
   IsolationInfo isolation_info = cache()->GetIsolationInfoForEndpoint(endpoint);
   EXPECT_TRUE(isolation_info.IsEqualForTesting(kIsolationInfo_));
-
   EXPECT_EQ(kOrigin1_, endpoint.group_key.origin);
   EXPECT_EQ(kGroup1_, endpoint.group_key.group_name);
   EXPECT_EQ(kEndpoint1_, endpoint.info.url);
diff --git a/chromium/net/reporting/reporting_network_change_observer.cc b/chromium/net/reporting/reporting_network_change_observer.cc
index f77dee50e6f..276bdf4ab86 100644
--- a/chromium/net/reporting/reporting_network_change_observer.cc
+++ b/chromium/net/reporting/reporting_network_change_observer.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_network_change_observer.h b/chromium/net/reporting/reporting_network_change_observer.h
index 941133d339e..2bbd2c529a5 100644
--- a/chromium/net/reporting/reporting_network_change_observer.h
+++ b/chromium/net/reporting/reporting_network_change_observer.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_network_change_observer_unittest.cc b/chromium/net/reporting/reporting_network_change_observer_unittest.cc
index d73388989a6..bb5edcee7e9 100644
--- a/chromium/net/reporting/reporting_network_change_observer_unittest.cc
+++ b/chromium/net/reporting/reporting_network_change_observer_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -46,7 +46,7 @@ class ReportingNetworkChangeObserverTest : public ReportingTestBase {
 
   const absl::optional<base::UnguessableToken> kReportingSource_ =
       absl::nullopt;
-  const NetworkIsolationKey kNik_;
+  const NetworkAnonymizationKey kNak_;
   const GURL kUrl_ = GURL("https://origin/path");
   const url::Origin kOrigin_ = url::Origin::Create(kUrl_);
   const GURL kEndpoint_ = GURL("https://endpoint/");
@@ -54,7 +54,7 @@ class ReportingNetworkChangeObserverTest : public ReportingTestBase {
   const std::string kGroup_ = "group";
   const std::string kType_ = "default";
   const ReportingEndpointGroupKey kGroupKey_ =
-      ReportingEndpointGroupKey(NetworkIsolationKey(), kOrigin_, kGroup_);
+      ReportingEndpointGroupKey(NetworkAnonymizationKey(), kOrigin_, kGroup_);
 };
 
 TEST_F(ReportingNetworkChangeObserverTest, ClearNothing) {
@@ -63,7 +63,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearNothing) {
   new_policy.persist_clients_across_network_changes = true;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl_, kUserAgent_, kGroup_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl_, kUserAgent_, kGroup_,
                      kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                      0);
   SetEndpoint();
@@ -82,7 +82,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearReports) {
   new_policy.persist_clients_across_network_changes = true;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl_, kUserAgent_, kGroup_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl_, kUserAgent_, kGroup_,
                      kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                      0);
   SetEndpoint();
@@ -101,7 +101,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearClients) {
   new_policy.persist_clients_across_network_changes = false;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl_, kUserAgent_, kGroup_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl_, kUserAgent_, kGroup_,
                      kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                      0);
   SetEndpoint();
@@ -120,7 +120,7 @@ TEST_F(ReportingNetworkChangeObserverTest, ClearReportsAndClients) {
   new_policy.persist_clients_across_network_changes = false;
   UsePolicy(new_policy);
 
-  cache()->AddReport(kReportingSource_, kNik_, kUrl_, kUserAgent_, kGroup_,
+  cache()->AddReport(kReportingSource_, kNak_, kUrl_, kUserAgent_, kGroup_,
                      kType_, base::Value::Dict(), 0, tick_clock()->NowTicks(),
                      0);
   SetEndpoint();
diff --git a/chromium/net/reporting/reporting_policy.cc b/chromium/net/reporting/reporting_policy.cc
index bb895c5122d..e348299f707 100644
--- a/chromium/net/reporting/reporting_policy.cc
+++ b/chromium/net/reporting/reporting_policy.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_policy.h b/chromium/net/reporting/reporting_policy.h
index 4edf578121d..a3e41f224df 100644
--- a/chromium/net/reporting/reporting_policy.h
+++ b/chromium/net/reporting/reporting_policy.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_policy.proto b/chromium/net/reporting/reporting_policy.proto
index 235101833de..6a386835b5d 100644
--- a/chromium/net/reporting/reporting_policy.proto
+++ b/chromium/net/reporting/reporting_policy.proto
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_report.cc b/chromium/net/reporting/reporting_report.cc
index d19a3485dfb..b0da461ae56 100644
--- a/chromium/net/reporting/reporting_report.cc
+++ b/chromium/net/reporting/reporting_report.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -16,17 +16,17 @@ namespace net {
 
 ReportingReport::ReportingReport(
     const absl::optional<base::UnguessableToken>& reporting_source,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const GURL& url,
     const std::string& user_agent,
     const std::string& group,
     const std::string& type,
-    std::unique_ptr<const base::Value> body,
+    base::Value::Dict body,
     int depth,
     base::TimeTicks queued,
     int attempts)
     : reporting_source(reporting_source),
-      network_isolation_key(network_isolation_key),
+      network_anonymization_key(network_anonymization_key),
       id(base::UnguessableToken::Create()),
       url(url),
       user_agent(user_agent),
@@ -46,7 +46,7 @@ ReportingReport& ReportingReport::operator=(ReportingReport&& other) = default;
 ReportingReport::~ReportingReport() = default;
 
 ReportingEndpointGroupKey ReportingReport::GetGroupKey() const {
-  return ReportingEndpointGroupKey(network_isolation_key, reporting_source,
+  return ReportingEndpointGroupKey(network_anonymization_key, reporting_source,
                                    url::Origin::Create(url), group);
 }
 
diff --git a/chromium/net/reporting/reporting_report.h b/chromium/net/reporting/reporting_report.h
index 3ed13a4508e..79a1248f37a 100644
--- a/chromium/net/reporting/reporting_report.h
+++ b/chromium/net/reporting/reporting_report.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -10,16 +10,13 @@
 
 #include "base/time/time.h"
 #include "base/unguessable_token.h"
+#include "base/values.h"
 #include "net/base/net_export.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_endpoint.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "url/gurl.h"
 
-namespace base {
-class Value;
-}  // namespace base
-
 namespace net {
 
 // An undelivered report.
@@ -45,12 +42,12 @@ struct NET_EXPORT ReportingReport {
   // TODO(chlily): Remove |attempts| argument as it is (almost?) always 0.
   ReportingReport(
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const GURL& url,
       const std::string& user_agent,
       const std::string& group,
       const std::string& type,
-      std::unique_ptr<const base::Value> body,
+      base::Value::Dict body,
       int depth,
       base::TimeTicks queued,
       int attempts);
@@ -87,9 +84,9 @@ struct NET_EXPORT ReportingReport {
   // (Not included in the delivered report.)
   absl::optional<base::UnguessableToken> reporting_source;
 
-  // The NIK of the request that triggered this report. (Not included in the
+  // The NAK of the request that triggered this report. (Not included in the
   // delivered report.)
-  NetworkIsolationKey network_isolation_key;
+  NetworkAnonymizationKey network_anonymization_key;
 
   // The id of the report, used by DevTools to identify and tell apart
   // individual reports.
@@ -110,7 +107,7 @@ struct NET_EXPORT ReportingReport {
   std::string type;
 
   // The body of the report. (Included in the delivered report.)
-  std::unique_ptr<const base::Value> body;
+  base::Value::Dict body;
 
   // How many uploads deep the related request was: 0 if the related request was
   // not an upload (or there was no related request), or n+1 if it was an upload
diff --git a/chromium/net/reporting/reporting_service.cc b/chromium/net/reporting/reporting_service.cc
index 02ed98a99b4..4c4fa2ccc85 100644
--- a/chromium/net/reporting/reporting_service.cc
+++ b/chromium/net/reporting/reporting_service.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -63,11 +63,12 @@ class ReportingServiceImpl : public ReportingService {
       const IsolationInfo& isolation_info,
       const base::flat_map<std::string, std::string>& endpoints) override {
     DCHECK(!reporting_source.is_empty());
-    DoOrBacklogTask(base::BindOnce(
-        &ReportingServiceImpl::DoSetDocumentReportingEndpoints,
-        base::Unretained(this), reporting_source, isolation_info,
-        FixupNetworkIsolationKey(isolation_info.network_isolation_key()),
-        origin, std::move(endpoints)));
+    DoOrBacklogTask(
+        base::BindOnce(&ReportingServiceImpl::DoSetDocumentReportingEndpoints,
+                       base::Unretained(this), reporting_source, isolation_info,
+                       FixupNetworkAnonymizationKey(
+                           isolation_info.network_anonymization_key()),
+                       origin, std::move(endpoints)));
   }
 
   void SendReportsAndRemoveSource(
@@ -80,7 +81,7 @@ class ReportingServiceImpl : public ReportingService {
   void QueueReport(
       const GURL& url,
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const std::string& user_agent,
       const std::string& group,
       const std::string& type,
@@ -103,16 +104,18 @@ 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),
-        reporting_source, FixupNetworkIsolationKey(network_isolation_key),
-        std::move(sanitized_url), user_agent, group, type, std::move(body),
-        depth, queued_ticks));
+    DoOrBacklogTask(
+        base::BindOnce(&ReportingServiceImpl::DoQueueReport,
+                       base::Unretained(this), reporting_source,
+                       FixupNetworkAnonymizationKey(network_anonymization_key),
+                       std::move(sanitized_url), user_agent, group, type,
+                       std::move(body), depth, queued_ticks));
   }
 
-  void ProcessReportToHeader(const url::Origin& origin,
-                             const NetworkIsolationKey& network_isolation_key,
-                             const std::string& header_string) override {
+  void ProcessReportToHeader(
+      const url::Origin& origin,
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const std::string& header_string) override {
     if (header_string.size() > kMaxJsonSize)
       return;
 
@@ -124,7 +127,7 @@ class ReportingServiceImpl : public ReportingService {
     DVLOG(1) << "Received Reporting policy for " << origin;
     DoOrBacklogTask(base::BindOnce(
         &ReportingServiceImpl::DoProcessReportToHeader, base::Unretained(this),
-        FixupNetworkIsolationKey(network_isolation_key), origin,
+        FixupNetworkAnonymizationKey(network_anonymization_key), origin,
         std::move(header_value).value()));
   }
 
@@ -200,7 +203,7 @@ class ReportingServiceImpl : public ReportingService {
 
   void DoQueueReport(
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       GURL sanitized_url,
       const std::string& user_agent,
       const std::string& group,
@@ -210,29 +213,31 @@ class ReportingServiceImpl : public ReportingService {
       base::TimeTicks queued_ticks) {
     DCHECK(initialized_);
     context_->cache()->AddReport(
-        reporting_source, network_isolation_key, sanitized_url, user_agent,
+        reporting_source, network_anonymization_key, sanitized_url, user_agent,
         group, type, std::move(body), depth, queued_ticks, 0 /* attempts */);
   }
 
-  void DoProcessReportToHeader(const NetworkIsolationKey& network_isolation_key,
-                               const url::Origin& origin,
-                               const base::Value& header_value) {
+  void DoProcessReportToHeader(
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const url::Origin& origin,
+      const base::Value& header_value) {
     DCHECK(initialized_);
     DCHECK(header_value.is_list());
-    ReportingHeaderParser::ParseReportToHeader(
-        context_.get(), network_isolation_key, origin, header_value.GetList());
+    ReportingHeaderParser::ParseReportToHeader(context_.get(),
+                                               network_anonymization_key,
+                                               origin, header_value.GetList());
   }
 
   void DoSetDocumentReportingEndpoints(
       const base::UnguessableToken& reporting_source,
       const IsolationInfo& isolation_info,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const url::Origin& origin,
       base::flat_map<std::string, std::string> header_value) {
     DCHECK(initialized_);
     ReportingHeaderParser::ProcessParsedReportingEndpointsHeader(
-        context_.get(), reporting_source, isolation_info, network_isolation_key,
-        origin, std::move(header_value));
+        context_.get(), reporting_source, isolation_info,
+        network_anonymization_key, origin, std::move(header_value));
   }
 
   void DoRemoveBrowsingData(
@@ -287,14 +292,15 @@ class ReportingServiceImpl : public ReportingService {
     ExecuteBacklog();
   }
 
-  // Returns either |network_isolation_key| or an empty NetworkIsolationKey,
-  // based on |respect_network_isolation_key_|. Should be used on all
-  // NetworkIsolationKeys passed in through public API calls.
-  const NetworkIsolationKey& FixupNetworkIsolationKey(
-      const NetworkIsolationKey& network_isolation_key) {
-    if (respect_network_isolation_key_)
-      return network_isolation_key;
-    return empty_nik_;
+  // Returns either |network_anonymization_key| or an empty
+  // NetworkAnonymizationKey, based on |respect_network_anonymization_key_|.
+  // Should be used on all NetworkAnonymizationKeys passed in through public API
+  // calls.
+  const NetworkAnonymizationKey& FixupNetworkAnonymizationKey(
+      const NetworkAnonymizationKey& network_anonymization_key) {
+    if (respect_network_anonymization_key_)
+      return network_anonymization_key;
+    return empty_nak_;
   }
 
   std::unique_ptr<ReportingContext> context_;
@@ -303,12 +309,12 @@ class ReportingServiceImpl : public ReportingService {
   bool initialized_ = false;
   std::vector<base::OnceClosure> task_backlog_;
 
-  bool respect_network_isolation_key_ = base::FeatureList::IsEnabled(
+  bool respect_network_anonymization_key_ = base::FeatureList::IsEnabled(
       features::kPartitionNelAndReportingByNetworkIsolationKey);
 
-  // Allows returning a NetworkIsolationKey by reference when
-  // |respect_network_isolation_key_| is false.
-  NetworkIsolationKey empty_nik_;
+  // Allows returning a NetworkAnonymizationKey by reference when
+  // |respect_network_anonymization_key_| is false.
+  NetworkAnonymizationKey empty_nak_;
 
   base::WeakPtrFactory<ReportingServiceImpl> weak_factory_{this};
 };
diff --git a/chromium/net/reporting/reporting_service.h b/chromium/net/reporting/reporting_service.h
index a473073a5bb..7bdae367612 100644
--- a/chromium/net/reporting/reporting_service.h
+++ b/chromium/net/reporting/reporting_service.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -29,7 +29,7 @@ class Origin;
 namespace net {
 
 class IsolationInfo;
-class NetworkIsolationKey;
+class NetworkAnonymizationKey;
 class ReportingContext;
 struct ReportingPolicy;
 class URLRequestContext;
@@ -62,7 +62,7 @@ class NET_EXPORT ReportingService {
   // |reporting_source| is the reporting source token for the document or
   // worker which triggered this report, if it can be associated with one, or
   // nullopt otherwise. If present, it may not be empty.
-  // Along with |network_isolation_key|, it is used to restrict what reports
+  // Along with |network_anonymization_key|, it is used to restrict what reports
   // can be merged, and for sending the report.
   // |user_agent| is the User-Agent header that was used for the request.
   // |group| is the endpoint group to which the report should be delivered.
@@ -73,7 +73,7 @@ class NET_EXPORT ReportingService {
   virtual void QueueReport(
       const GURL& url,
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const std::string& user_agent,
       const std::string& group,
       const std::string& type,
@@ -85,7 +85,7 @@ class NET_EXPORT ReportingService {
   // header.
   virtual void ProcessReportToHeader(
       const url::Origin& origin,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const std::string& header_value) = 0;
 
   // Configures reporting endpoints set by the Reporting-Endpoints header, once
diff --git a/chromium/net/reporting/reporting_service_unittest.cc b/chromium/net/reporting/reporting_service_unittest.cc
index 4307df3fbfa..1901b3897c7 100644
--- a/chromium/net/reporting/reporting_service_unittest.cc
+++ b/chromium/net/reporting/reporting_service_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -15,7 +15,7 @@
 #include "base/values.h"
 #include "net/base/features.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/reporting/mock_persistent_reporting_store.h"
 #include "net/reporting/reporting_browsing_data_remover.h"
@@ -55,10 +55,11 @@ class ReportingServiceTest : public ::testing::TestWithParam<bool>,
   const std::string kType_ = "type";
   const absl::optional<base::UnguessableToken> kReportingSource_ =
       base::UnguessableToken::Create();
-  const NetworkIsolationKey kNik_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin_), SchemefulSite(kOrigin_));
-  const NetworkIsolationKey kNik2_ =
-      NetworkIsolationKey(SchemefulSite(kOrigin2_), SchemefulSite(kOrigin2_));
+  const NetworkAnonymizationKey kNik_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin_), SchemefulSite(kOrigin_));
+  const NetworkAnonymizationKey kNik2_ =
+      NetworkAnonymizationKey(SchemefulSite(kOrigin2_),
+                              SchemefulSite(kOrigin2_));
   const ReportingEndpointGroupKey kGroupKey_ =
       ReportingEndpointGroupKey(kNik_, kOrigin_, kGroup_);
   const ReportingEndpointGroupKey kGroupKey2_ =
@@ -120,7 +121,7 @@ TEST_P(ReportingServiceTest, QueueReport) {
   context()->cache()->GetReports(&reports);
   ASSERT_EQ(1u, reports.size());
   EXPECT_EQ(kUrl_, reports[0]->url);
-  EXPECT_EQ(kNik_, reports[0]->network_isolation_key);
+  EXPECT_EQ(kNik_, reports[0]->network_anonymization_key);
   EXPECT_EQ(kUserAgent_, reports[0]->user_agent);
   EXPECT_EQ(kGroup_, reports[0]->group);
   EXPECT_EQ(kType_, reports[0]->type);
@@ -137,7 +138,7 @@ TEST_P(ReportingServiceTest, QueueReportSanitizeUrl) {
   context()->cache()->GetReports(&reports);
   ASSERT_EQ(1u, reports.size());
   EXPECT_EQ(kUrl_, reports[0]->url);
-  EXPECT_EQ(kNik_, reports[0]->network_isolation_key);
+  EXPECT_EQ(kNik_, reports[0]->network_anonymization_key);
   EXPECT_EQ(kUserAgent_, reports[0]->user_agent);
   EXPECT_EQ(kGroup_, reports[0]->group);
   EXPECT_EQ(kType_, reports[0]->type);
@@ -171,9 +172,9 @@ TEST_P(ReportingServiceTest, QueueReportNetworkIsolationKeyDisabled) {
   context()->cache()->GetReports(&reports);
   ASSERT_EQ(1u, reports.size());
 
-  // NetworkIsolationKey should be empty, instead of kNik_;
-  EXPECT_EQ(NetworkIsolationKey(), reports[0]->network_isolation_key);
-  EXPECT_NE(kNik_, reports[0]->network_isolation_key);
+  // NetworkAnonymizationKey should be empty, instead of kNik_;
+  EXPECT_EQ(NetworkAnonymizationKey(), reports[0]->network_anonymization_key);
+  EXPECT_NE(kNik_, reports[0]->network_anonymization_key);
 
   EXPECT_EQ(kUrl_, reports[0]->url);
   EXPECT_EQ(kUserAgent_, reports[0]->user_agent);
@@ -215,7 +216,7 @@ TEST_P(ReportingServiceTest, ProcessReportingEndpointsHeader) {
   EXPECT_TRUE(cached_endpoint);
 
   // Ensure that the NIK is stored properly with the endpoint group.
-  EXPECT_FALSE(cached_endpoint.group_key.network_isolation_key.IsEmpty());
+  EXPECT_FALSE(cached_endpoint.group_key.network_anonymization_key.IsEmpty());
 }
 
 TEST_P(ReportingServiceTest,
@@ -243,7 +244,7 @@ TEST_P(ReportingServiceTest,
   EXPECT_TRUE(cached_endpoint);
 
   // When isolation is disabled, cached endpoints should have a null NIK.
-  EXPECT_TRUE(cached_endpoint.group_key.network_isolation_key.IsEmpty());
+  EXPECT_TRUE(cached_endpoint.group_key.network_anonymization_key.IsEmpty());
 }
 
 TEST_P(ReportingServiceTest, SendReportsAndRemoveSource) {
@@ -281,7 +282,16 @@ TEST_P(ReportingServiceTest, SendReportsAndRemoveSource) {
       context()->cache()->GetExpiredSources().contains(*kReportingSource_));
 }
 
-TEST_P(ReportingServiceTest, SendReportsAndRemoveSourceWithPendingReports) {
+// Flaky in ChromeOS: crbug.com/1356127
+#if BUILDFLAG(IS_CHROMEOS)
+#define MAYBE_SendReportsAndRemoveSourceWithPendingReports \
+  DISABLED_SendReportsAndRemoveSourceWithPendingReports
+#else
+#define MAYBE_SendReportsAndRemoveSourceWithPendingReports \
+  SendReportsAndRemoveSourceWithPendingReports
+#endif
+TEST_P(ReportingServiceTest,
+       MAYBE_SendReportsAndRemoveSourceWithPendingReports) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(net::features::kDocumentReporting);
   auto parsed_header =
@@ -416,7 +426,7 @@ TEST_P(ReportingServiceTest, ProcessReportToHeaderNetworkIsolationKeyDisabled) {
   EXPECT_FALSE(context()->cache()->GetEndpointForTesting(
       ReportingEndpointGroupKey(kNik_, kOrigin_, kGroup_), kEndpoint_));
   EXPECT_TRUE(context()->cache()->GetEndpointForTesting(
-      ReportingEndpointGroupKey(NetworkIsolationKey(), kOrigin_, kGroup_),
+      ReportingEndpointGroupKey(NetworkAnonymizationKey(), kOrigin_, kGroup_),
       kEndpoint_));
 }
 
diff --git a/chromium/net/reporting/reporting_test_util.cc b/chromium/net/reporting/reporting_test_util.cc
index f39c2820f46..bfe50890a65 100644
--- a/chromium/net/reporting/reporting_test_util.cc
+++ b/chromium/net/reporting/reporting_test_util.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -18,7 +18,7 @@
 #include "base/test/simple_test_tick_clock.h"
 #include "base/timer/mock_timer.h"
 #include "net/base/isolation_info.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_delegate.h"
@@ -313,14 +313,14 @@ TestReportingService::Report::Report(Report&& other) = default;
 
 TestReportingService::Report::Report(
     const GURL& url,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const std::string& user_agent,
     const std::string& group,
     const std::string& type,
     std::unique_ptr<const base::Value> body,
     int depth)
     : url(url),
-      network_isolation_key(network_isolation_key),
+      network_anonymization_key(network_anonymization_key),
       user_agent(user_agent),
       group(group),
       type(type),
@@ -336,20 +336,20 @@ TestReportingService::~TestReportingService() = default;
 void TestReportingService::QueueReport(
     const GURL& url,
     const absl::optional<base::UnguessableToken>& reporting_source,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const std::string& user_agent,
     const std::string& group,
     const std::string& type,
     base::Value::Dict body,
     int depth) {
   reports_.emplace_back(
-      Report(url, network_isolation_key, user_agent, group, type,
+      Report(url, network_anonymization_key, user_agent, group, type,
              std::make_unique<base::Value>(std::move(body)), depth));
 }
 
 void TestReportingService::ProcessReportToHeader(
     const url::Origin& origin,
-    const NetworkIsolationKey& network_isolation_key,
+    const NetworkAnonymizationKey& network_anonymization_key,
     const std::string& header_value) {
   NOTREACHED();
 }
diff --git a/chromium/net/reporting/reporting_test_util.h b/chromium/net/reporting/reporting_test_util.h
index f25577d3cee..61296c3dfcb 100644
--- a/chromium/net/reporting/reporting_test_util.h
+++ b/chromium/net/reporting/reporting_test_util.h
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -14,7 +14,7 @@
 #include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/unguessable_token.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/rand_callback.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_context.h"
@@ -303,7 +303,7 @@ class TestReportingService : public ReportingService {
     Report(Report&& other);
 
     Report(const GURL& url,
-           const NetworkIsolationKey& network_isolation_key,
+           const NetworkAnonymizationKey& network_anonymization_key,
            const std::string& user_agent,
            const std::string& group,
            const std::string& type,
@@ -313,7 +313,7 @@ class TestReportingService : public ReportingService {
     ~Report();
 
     GURL url;
-    NetworkIsolationKey network_isolation_key;
+    NetworkAnonymizationKey network_anonymization_key;
     std::string user_agent;
     std::string group;
     std::string type;
@@ -344,16 +344,17 @@ class TestReportingService : public ReportingService {
   void QueueReport(
       const GURL& url,
       const absl::optional<base::UnguessableToken>& reporting_source,
-      const NetworkIsolationKey& network_isolation_key,
+      const NetworkAnonymizationKey& network_anonymization_key,
       const std::string& user_agent,
       const std::string& group,
       const std::string& type,
       base::Value::Dict body,
       int depth) override;
 
-  void ProcessReportToHeader(const url::Origin& url,
-                             const NetworkIsolationKey& network_isolation_key,
-                             const std::string& header_value) override;
+  void ProcessReportToHeader(
+      const url::Origin& url,
+      const NetworkAnonymizationKey& network_anonymization_key,
+      const std::string& header_value) override;
 
   void RemoveBrowsingData(
       uint64_t data_type_mask,
diff --git a/chromium/net/reporting/reporting_uploader.cc b/chromium/net/reporting/reporting_uploader.cc
index 3aa46ce7a8e..d7df44ded23 100644
--- a/chromium/net/reporting/reporting_uploader.cc
+++ b/chromium/net/reporting/reporting_uploader.cc
@@ -1,4 +1,4 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -15,7 +15,7 @@
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/isolation_info.h"
 #include "net/base/load_flags.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
@@ -200,11 +200,12 @@ class ReportingUploaderImpl : public ReportingUploader, URLRequest::Delegate {
     upload->request->set_site_for_cookies(
         upload->isolation_info.site_for_cookies());
     // Prior to using `isolation_info` directly here we built the
-    // `upload->network_isolation_key` to create the set the `isolation_info`.
-    // As experiments roll out to determine whether network partitions should be
-    // double or triple keyed the isolation_info might have a null value for
-    // `frame_origin`. Thus we should again get it from `network_isolation_key`
-    // until we can trust `isolation_info::frame_origin`.
+    // `upload->network_anonymization_key` to create the set the
+    // `isolation_info`. As experiments roll out to determine whether network
+    // partitions should be double or triple keyed the isolation_info might have
+    // a null value for `frame_origin`. Thus we should again get it from
+    // `network_anonymization_key` until we can trust
+    // `isolation_info::frame_origin`.
     upload->request->set_initiator(upload->report_origin);
     upload->request->set_isolation_info(upload->isolation_info);
 
diff --git a/chromium/net/reporting/reporting_uploader.h b/chromium/net/reporting/reporting_uploader.h
index 7749cd54e69..5466773d9b9 100644
--- a/chromium/net/reporting/reporting_uploader.h
+++ b/chromium/net/reporting/reporting_uploader.h
@@ -1,4 +1,4 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/chromium/net/reporting/reporting_uploader_unittest.cc b/chromium/net/reporting/reporting_uploader_unittest.cc
index c4147003914..b8b4ed4ac6f 100644
--- a/chromium/net/reporting/reporting_uploader_unittest.cc
+++ b/chromium/net/reporting/reporting_uploader_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -13,7 +13,7 @@
 #include "base/run_loop.h"
 #include "base/test/scoped_feature_list.h"
 #include "net/base/features.h"
-#include "net/base/network_isolation_key.h"
+#include "net/base/network_anonymization_key.h"
 #include "net/base/schemeful_site.h"
 #include "net/cookies/cookie_access_result.h"
 #include "net/cookies/cookie_store.h"
@@ -621,14 +621,14 @@ TEST_F(ReportingUploaderTest, DontCacheResponse) {
   EXPECT_EQ(2, request_count);
 }
 
-// Create two requests with the same NetworkIsolationKey, and one request with a
-// different one, and make sure only the requests with the same
-// NetworkIsolationKey share a socket.
-TEST_F(ReportingUploaderTest, RespectsNetworkIsolationKey) {
+// Create two requests with the same NetworkAnonymizationKey, and one request
+// with a different one, and make sure only the requests with the same
+// NetworkAnonymizationKey share a socket.
+TEST_F(ReportingUploaderTest, RespectsNetworkAnonymizationKey) {
   // While features::kPartitionConnectionsByNetworkIsolationKey is not needed
-  // for reporting code to respect NetworkIsolationKeys, this test works by
-  // ensuring that Reporting's NetworkIsolationKey makes it to the socket pool
-  // layer and is respected there, so this test needs to enable
+  // for reporting code to respect NetworkAnonymizationKey, this test works by
+  // ensuring that Reporting's NetworkAnonymizationKey makes it to the socket
+  // pool layer and is respected there, so this test needs to enable
   // kPartitionConnectionsByNetworkIsolationKey.
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
@@ -720,8 +720,8 @@ TEST_F(ReportingUploaderTest, RespectsNetworkIsolationKey) {
   EXPECT_EQ(ReportingUploader::Outcome::SUCCESS, callback1.outcome());
 
   // Start two more requests in parallel. The first started uses a different
-  // NetworkIsolationKey, so should create a new socket, while the second one
-  // gets the other socket. Start in parallel to make sure that a new socket
+  // NetworkAnonymizationKey, so should create a new socket, while the second
+  // one gets the other socket. Start in parallel to make sure that a new socket
   // isn't created just because the first is returned to the socket pool
   // asynchronously.
   TestUploadCallback callback2;