BASELINE: Update Chromium to 68.0.3440.125

Change-Id: I23f19369e01f688e496f5bf179abb521ad73874f
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

11 files changed, 348 insertions, 25 deletions

diff --git a/chromium/net/reporting/reporting_browsing_data_remover.cc b/chromium/net/reporting/reporting_browsing_data_remover.cc
index 8f42253c9a8..413ad65dd5f 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover.cc
+++ b/chromium/net/reporting/reporting_browsing_data_remover.cc
@@ -18,20 +18,7 @@ void ReportingBrowsingDataRemover::RemoveBrowsingData(
     ReportingCache* cache,
     int data_type_mask,
     const base::RepeatingCallback<bool(const GURL&)>& origin_filter) {
-  bool remove_reports = (data_type_mask & DATA_TYPE_REPORTS) != 0;
-  bool remove_clients = (data_type_mask & DATA_TYPE_CLIENTS) != 0;
-
-  if (origin_filter.is_null()) {
-    if (remove_reports) {
-      cache->RemoveAllReports(
-          ReportingReport::Outcome::ERASED_BROWSING_DATA_REMOVED);
-    }
-    if (remove_clients)
-      cache->RemoveAllClients();
-    return;
-  }
-
-  if (remove_reports) {
+  if ((data_type_mask & DATA_TYPE_REPORTS) != 0) {
     std::vector<const ReportingReport*> all_reports;
     cache->GetReports(&all_reports);
 
@@ -46,7 +33,7 @@ void ReportingBrowsingDataRemover::RemoveBrowsingData(
         ReportingReport::Outcome::ERASED_BROWSING_DATA_REMOVED);
   }
 
-  if (remove_clients) {
+  if ((data_type_mask & DATA_TYPE_CLIENTS) != 0) {
     std::vector<const ReportingClient*> all_clients;
     cache->GetClients(&all_clients);
 
@@ -61,4 +48,16 @@ void ReportingBrowsingDataRemover::RemoveBrowsingData(
   }
 }
 
+// static
+void ReportingBrowsingDataRemover::RemoveAllBrowsingData(ReportingCache* cache,
+                                                         int data_type_mask) {
+  if ((data_type_mask & DATA_TYPE_REPORTS) != 0) {
+    cache->RemoveAllReports(
+        ReportingReport::Outcome::ERASED_BROWSING_DATA_REMOVED);
+  }
+  if ((data_type_mask & DATA_TYPE_CLIENTS) != 0) {
+    cache->RemoveAllClients();
+  }
+}
+
 }  // namespace net
diff --git a/chromium/net/reporting/reporting_browsing_data_remover.h b/chromium/net/reporting/reporting_browsing_data_remover.h
index abb34bc9d25..ce3df31ffc0 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover.h
+++ b/chromium/net/reporting/reporting_browsing_data_remover.h
@@ -24,8 +24,8 @@ class NET_EXPORT ReportingBrowsingDataRemover {
 
   // Removes browsing data from the Reporting system. |data_type_mask| specifies
   // which types of data to remove: reports queued by browser features and/or
-  // clients (endpoints configured by origins). |origin_filter|, if not null,
-  // specifies which origins' data to remove.
+  // clients (endpoints configured by origins). |origin_filter| specifies which
+  // origins' data to remove.
   //
   // Note: Currently this does not clear the endpoint backoff data in
   // ReportingEndpointManager because that's not persisted to disk. If it's ever
@@ -35,6 +35,11 @@ class NET_EXPORT ReportingBrowsingDataRemover {
       int data_type_mask,
       const base::RepeatingCallback<bool(const GURL&)>& origin_filter);
 
+  // Like RemoveBrowsingData except removes data for all origins without a
+  // filter. Allows slight optimization over passing an always-true filter to
+  // RemoveBrowsingData.
+  static void RemoveAllBrowsingData(ReportingCache* cache, int data_type_mask);
+
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReportingBrowsingDataRemover);
 };
diff --git a/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc b/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
index 7e720e98ff9..070480649a8 100644
--- a/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
+++ b/chromium/net/reporting/reporting_browsing_data_remover_unittest.cc
@@ -29,14 +29,15 @@ class ReportingBrowsingDataRemoverTest : public ReportingTestBase {
     if (remove_clients)
       data_type_mask |= ReportingBrowsingDataRemover::DATA_TYPE_CLIENTS;
 
-    base::RepeatingCallback<bool(const GURL&)> origin_filter;
     if (!host.empty()) {
-      origin_filter =
+      base::RepeatingCallback<bool(const GURL&)> origin_filter =
           base::BindRepeating(&ReportingBrowsingDataRemoverTest::HostIs, host);
+      ReportingBrowsingDataRemover::RemoveBrowsingData(cache(), data_type_mask,
+                                                       origin_filter);
+    } else {
+      ReportingBrowsingDataRemover::RemoveAllBrowsingData(cache(),
+                                                          data_type_mask);
     }
-
-    ReportingBrowsingDataRemover::RemoveBrowsingData(cache(), data_type_mask,
-                                                     origin_filter);
   }
 
   void AddReport(const GURL& url) {
diff --git a/chromium/net/reporting/reporting_cache.cc b/chromium/net/reporting/reporting_cache.cc
index 61fbd3947b8..0df79562b14 100644
--- a/chromium/net/reporting/reporting_cache.cc
+++ b/chromium/net/reporting/reporting_cache.cc
@@ -4,6 +4,7 @@
 
 #include "net/reporting/reporting_cache.h"
 
+#include <algorithm>
 #include <map>
 #include <set>
 #include <string>
@@ -15,6 +16,7 @@
 #include "base/stl_util.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
+#include "net/log/net_log.h"
 #include "net/reporting/reporting_client.h"
 #include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_report.h"
@@ -106,6 +108,49 @@ class ReportingCacheImpl : public ReportingCache {
     }
   }
 
+  base::Value GetReportsAsValue() const override {
+    // Sort the queued reports by origin and timestamp.
+    std::vector<const ReportingReport*> sorted_reports;
+    sorted_reports.reserve(reports_.size());
+    for (const auto& it : reports_) {
+      sorted_reports.push_back(it.second.get());
+    }
+    std::sort(
+        sorted_reports.begin(), sorted_reports.end(),
+        [](const ReportingReport* report1, const ReportingReport* report2) {
+          if (report1->queued < report2->queued)
+            return true;
+          else if (report1->queued > report2->queued)
+            return false;
+          else
+            return report1->url < report2->url;
+        });
+
+    std::vector<base::Value> report_list;
+    for (const ReportingReport* report : sorted_reports) {
+      base::Value report_dict(base::Value::Type::DICTIONARY);
+      report_dict.SetKey("url", base::Value(report->url.spec()));
+      report_dict.SetKey("group", base::Value(report->group));
+      report_dict.SetKey("type", base::Value(report->type));
+      report_dict.SetKey("depth", base::Value(report->depth));
+      report_dict.SetKey(
+          "queued", base::Value(NetLog::TickCountToString(report->queued)));
+      report_dict.SetKey("attempts", base::Value(report->attempts));
+      if (report->body) {
+        report_dict.SetKey("body", report->body->Clone());
+      }
+      if (base::ContainsKey(doomed_reports_, report)) {
+        report_dict.SetKey("status", base::Value("doomed"));
+      } else if (base::ContainsKey(pending_reports_, report)) {
+        report_dict.SetKey("status", base::Value("pending"));
+      } else {
+        report_dict.SetKey("status", base::Value("queued"));
+      }
+      report_list.push_back(std::move(report_dict));
+    }
+    return base::Value(std::move(report_list));
+  }
+
   void GetNonpendingReports(
       std::vector<const ReportingReport*>* reports_out) const override {
     reports_out->clear();
@@ -263,6 +308,73 @@ class ReportingCacheImpl : public ReportingCache {
         clients_out->push_back(endpoint_and_client.second.get());
   }
 
+  base::Value GetClientsAsValue() const override {
+    std::map<const url::Origin,
+             std::map<const std::string, std::vector<const ReportingClient*>>>
+        clients_by_origin_and_group;
+    for (const auto& it : clients_) {
+      const url::Origin& origin = it.first;
+      for (const auto& endpoint_and_client : it.second) {
+        const ReportingClient* client = endpoint_and_client.second.get();
+        clients_by_origin_and_group[origin][client->group].push_back(client);
+      }
+    }
+
+    std::vector<base::Value> origin_list;
+    for (const auto& it : clients_by_origin_and_group) {
+      const url::Origin& origin = it.first;
+      base::Value origin_dict(base::Value::Type::DICTIONARY);
+      origin_dict.SetKey("origin", base::Value(origin.Serialize()));
+      std::vector<base::Value> group_list;
+      for (const auto& group_and_clients : it.second) {
+        const std::string& group = group_and_clients.first;
+        const std::vector<const ReportingClient*>& clients =
+            group_and_clients.second;
+        base::Value group_dict(base::Value::Type::DICTIONARY);
+        group_dict.SetKey("name", base::Value(group));
+        std::vector<base::Value> endpoint_list;
+        for (const ReportingClient* client : clients) {
+          base::Value endpoint_dict(base::Value::Type::DICTIONARY);
+          // Reporting defines the group as a whole to have an expiration time
+          // and subdomains flag, not the individual endpoints within the group.
+          group_dict.SetKey(
+              "expires",
+              base::Value(NetLog::TickCountToString(client->expires)));
+          group_dict.SetKey("includeSubdomains",
+                            base::Value(client->subdomains ==
+                                        ReportingClient::Subdomains::INCLUDE));
+          endpoint_dict.SetKey("url", base::Value(client->endpoint.spec()));
+          endpoint_dict.SetKey("priority", base::Value(client->priority));
+          endpoint_dict.SetKey("weight", base::Value(client->weight));
+          auto metadata_it = client_metadata_.find(client);
+          if (metadata_it != client_metadata_.end()) {
+            const ClientStatistics& stats = metadata_it->second.stats;
+            base::Value successful_dict(base::Value::Type::DICTIONARY);
+            successful_dict.SetKey("uploads",
+                                   base::Value(stats.successful_uploads));
+            successful_dict.SetKey("reports",
+                                   base::Value(stats.successful_reports));
+            endpoint_dict.SetKey("successful", std::move(successful_dict));
+            base::Value failed_dict(base::Value::Type::DICTIONARY);
+            failed_dict.SetKey("uploads",
+                               base::Value(stats.attempted_uploads -
+                                           stats.successful_uploads));
+            failed_dict.SetKey("reports",
+                               base::Value(stats.attempted_reports -
+                                           stats.successful_reports));
+            endpoint_dict.SetKey("failed", std::move(failed_dict));
+          }
+          endpoint_list.push_back(std::move(endpoint_dict));
+        }
+        group_dict.SetKey("endpoints", base::Value(std::move(endpoint_list)));
+        group_list.push_back(std::move(group_dict));
+      }
+      origin_dict.SetKey("groups", base::Value(std::move(group_list)));
+      origin_list.push_back(std::move(origin_dict));
+    }
+    return base::Value(std::move(origin_list));
+  }
+
   void GetClientsForOriginAndGroup(
       const url::Origin& origin,
       const std::string& group,
diff --git a/chromium/net/reporting/reporting_cache.h b/chromium/net/reporting/reporting_cache.h
index 6711577ef5e..71334220893 100644
--- a/chromium/net/reporting/reporting_cache.h
+++ b/chromium/net/reporting/reporting_cache.h
@@ -76,6 +76,10 @@ class NET_EXPORT ReportingCache {
   virtual void GetReports(
       std::vector<const ReportingReport*>* reports_out) const = 0;
 
+  // Gets all reports in the cache, including pending and doomed reports, as a
+  // base::Value.
+  virtual base::Value GetReportsAsValue() const = 0;
+
   // Gets all reports in the cache that aren't pending. The returned pointers
   // are valid as long as either no calls to |RemoveReports| have happened or
   // the reports' |pending| flag has been set to true using |SetReportsPending|.
@@ -139,6 +143,10 @@ class NET_EXPORT ReportingCache {
   virtual void GetClients(
       std::vector<const ReportingClient*>* clients_out) const = 0;
 
+  // Gets information about all of the clients in the cache, encoded as a
+  // base::Value.
+  virtual base::Value GetClientsAsValue() const = 0;
+
   // Gets all of the clients configured for a particular origin in a particular
   // group. The returned pointers are only guaranteed to be valid if no calls
   // have been made to |SetClient| or |RemoveEndpoint| in between.
diff --git a/chromium/net/reporting/reporting_cache_unittest.cc b/chromium/net/reporting/reporting_cache_unittest.cc
index de65ee4e728..a2fbb9e4436 100644
--- a/chromium/net/reporting/reporting_cache_unittest.cc
+++ b/chromium/net/reporting/reporting_cache_unittest.cc
@@ -4,10 +4,12 @@
 
 #include "net/reporting/reporting_cache.h"
 
+#include <algorithm>
 #include <string>
 
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "base/test/values_test_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/reporting/reporting_client.h"
@@ -72,7 +74,51 @@ class ReportingCacheTest : public ReportingTestBase {
                        ReportingClient::kDefaultWeight);
   }
 
+  // Adds a new report to the cache, and returns it.
+  const ReportingReport* AddAndReturnReport(
+      const GURL& url,
+      const std::string& group,
+      const std::string& type,
+      std::unique_ptr<const base::Value> body,
+      int depth,
+      base::TimeTicks queued,
+      int attempts) {
+    const base::Value* body_unowned = body.get();
+
+    // 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
+    // we add, and return the one element that's different.  This is only used
+    // in test cases, so I've optimized for readability over execution speed.
+    std::vector<const ReportingReport*> before;
+    cache()->GetReports(&before);
+    cache()->AddReport(url, 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()) {
+        // Sanity check the result before we return it.
+        EXPECT_EQ(url, report->url);
+        EXPECT_EQ(group, report->group);
+        EXPECT_EQ(type, report->type);
+        EXPECT_EQ(*body_unowned, *report->body);
+        EXPECT_EQ(depth, report->depth);
+        EXPECT_EQ(queued, report->queued);
+        EXPECT_EQ(attempts, report->attempts);
+        return report;
+      }
+    }
+
+    // This can actually happen!  If the newly created report isn't in the after
+    // vector, that means that we had to evict a report, and the new report was
+    // the only one eligible for eviction!
+    return nullptr;
+  }
+
   const GURL kUrl1_ = GURL("https://origin1/path");
+  const GURL kUrl2_ = GURL("https://origin2/path");
   const url::Origin kOrigin1_ = url::Origin::Create(GURL("https://origin1/"));
   const url::Origin kOrigin2_ = url::Origin::Create(GURL("https://origin2/"));
   const GURL kEndpoint1_ = GURL("https://endpoint1/");
@@ -206,6 +252,73 @@ TEST_F(ReportingCacheTest, RemoveAllPendingReports) {
   EXPECT_EQ(0u, cache()->GetFullReportCountForTesting());
 }
 
+TEST_F(ReportingCacheTest, GetReportsAsValue) {
+  // We need a reproducible expiry timestamp for this test case.
+  const base::TimeTicks now = base::TimeTicks();
+  const ReportingReport* report1 = AddAndReturnReport(
+      kUrl1_, kGroup1_, kType_, std::make_unique<base::DictionaryValue>(), 0,
+      now + base::TimeDelta::FromSeconds(200), 0);
+  const ReportingReport* report2 = AddAndReturnReport(
+      kUrl1_, kGroup2, kType_, std::make_unique<base::DictionaryValue>(), 0,
+      now + base::TimeDelta::FromSeconds(100), 1);
+  cache()->AddReport(kUrl2_, kGroup1_, kType_,
+                     std::make_unique<base::DictionaryValue>(), 2,
+                     now + base::TimeDelta::FromSeconds(200), 0);
+  cache()->AddReport(kUrl1_, kGroup1_, kType_,
+                     std::make_unique<base::DictionaryValue>(), 0,
+                     now + base::TimeDelta::FromSeconds(300), 0);
+  // Mark report1 as pending as report2 as doomed
+  cache()->SetReportsPending({report1, report2});
+  cache()->RemoveReports({report2}, ReportingReport::Outcome::UNKNOWN);
+
+  base::Value actual = cache()->GetReportsAsValue();
+  std::unique_ptr<base::Value> expected = base::test::ParseJson(R"json(
+      [
+        {
+          "url": "https://origin1/path",
+          "group": "group2",
+          "type": "default",
+          "status": "doomed",
+          "body": {},
+          "attempts": 1,
+          "depth": 0,
+          "queued": "100000",
+        },
+        {
+          "url": "https://origin1/path",
+          "group": "group1",
+          "type": "default",
+          "status": "pending",
+          "body": {},
+          "attempts": 0,
+          "depth": 0,
+          "queued": "200000",
+        },
+        {
+          "url": "https://origin2/path",
+          "group": "group1",
+          "type": "default",
+          "status": "queued",
+          "body": {},
+          "attempts": 0,
+          "depth": 2,
+          "queued": "200000",
+        },
+        {
+          "url": "https://origin1/path",
+          "group": "group1",
+          "type": "default",
+          "status": "queued",
+          "body": {},
+          "attempts": 0,
+          "depth": 0,
+          "queued": "300000",
+        },
+      ]
+      )json");
+  EXPECT_EQ(*expected, actual);
+}
+
 TEST_F(ReportingCacheTest, Endpoints) {
   SetClient(kOrigin1_, kEndpoint1_, false, kGroup1_, kExpires1_);
   EXPECT_EQ(1, observer()->cache_update_count());
@@ -291,6 +404,64 @@ TEST_F(ReportingCacheTest, RemoveClientsForEndpoint) {
   EXPECT_TRUE(clients.empty());
 }
 
+TEST_F(ReportingCacheTest, GetClientsAsValue) {
+  // We need a reproducible expiry timestamp for this test case.
+  const base::TimeTicks expires =
+      base::TimeTicks() + base::TimeDelta::FromDays(7);
+  SetClient(kOrigin1_, kEndpoint1_, false, kGroup1_, expires);
+  SetClient(kOrigin2_, kEndpoint2_, true, kGroup1_, expires);
+
+  // Add some reports so that we can test the upload counts.
+  const ReportingReport* report1a = AddAndReturnReport(
+      kUrl1_, kGroup1_, kType_, std::make_unique<base::DictionaryValue>(), 0,
+      expires, 0);
+  const ReportingReport* report1b = AddAndReturnReport(
+      kUrl1_, kGroup1_, kType_, std::make_unique<base::DictionaryValue>(), 0,
+      expires, 1);
+  const ReportingReport* report2 = AddAndReturnReport(
+      kUrl2_, kGroup1_, kType_, std::make_unique<base::DictionaryValue>(), 0,
+      expires, 1);
+  cache()->IncrementEndpointDeliveries(kEndpoint1_, {report1a, report1b}, true);
+  cache()->IncrementEndpointDeliveries(kEndpoint2_, {report2}, false);
+
+  base::Value actual = cache()->GetClientsAsValue();
+  std::unique_ptr<base::Value> expected = base::test::ParseJson(R"json(
+      [
+        {
+          "origin": "https://origin1",
+          "groups": [
+            {
+              "name": "group1",
+              "expires": "604800000",
+              "includeSubdomains": false,
+              "endpoints": [
+                {"url": "https://endpoint1/", "priority": 0, "weight": 1,
+                 "successful": {"uploads": 1, "reports": 2},
+                 "failed": {"uploads": 0, "reports": 0}},
+              ],
+            },
+          ],
+        },
+        {
+          "origin": "https://origin2",
+          "groups": [
+            {
+              "name": "group1",
+              "expires": "604800000",
+              "includeSubdomains": true,
+              "endpoints": [
+                {"url": "https://endpoint2/", "priority": 0, "weight": 1,
+                 "successful": {"uploads": 0, "reports": 0},
+                 "failed": {"uploads": 1, "reports": 1}},
+              ],
+            },
+          ],
+        },
+      ]
+      )json");
+  EXPECT_EQ(*expected, actual);
+}
+
 TEST_F(ReportingCacheTest, RemoveAllClients) {
   SetClient(kOrigin1_, kEndpoint1_, false, kGroup1_, kExpires1_);
   SetClient(kOrigin2_, kEndpoint2_, false, kGroup1_, kExpires1_);
diff --git a/chromium/net/reporting/reporting_service.cc b/chromium/net/reporting/reporting_service.cc
index ce1efb0f28f..fc53e4e3a2d 100644
--- a/chromium/net/reporting/reporting_service.cc
+++ b/chromium/net/reporting/reporting_service.cc
@@ -65,6 +65,11 @@ class ReportingServiceImpl : public ReportingService {
         context_->cache(), data_type_mask, origin_filter);
   }
 
+  void RemoveAllBrowsingData(int data_type_mask) override {
+    ReportingBrowsingDataRemover::RemoveAllBrowsingData(context_->cache(),
+                                                        data_type_mask);
+  }
+
   int GetUploadDepth(const URLRequest& request) override {
     return context_->uploader()->GetUploadDepth(request);
   }
@@ -73,6 +78,14 @@ class ReportingServiceImpl : public ReportingService {
     return context_->policy();
   }
 
+  base::Value StatusAsValue() const override {
+    base::Value dict(base::Value::Type::DICTIONARY);
+    dict.SetKey("reportingEnabled", base::Value(true));
+    dict.SetKey("clients", context_->cache()->GetClientsAsValue());
+    dict.SetKey("reports", context_->cache()->GetReportsAsValue());
+    return dict;
+  }
+
  private:
   void ProcessHeaderValue(const GURL& url, std::unique_ptr<base::Value> value) {
     ReportingHeaderParser::ParseHeader(context_.get(), url, std::move(value));
@@ -102,4 +115,9 @@ std::unique_ptr<ReportingService> ReportingService::CreateForTesting(
   return std::make_unique<ReportingServiceImpl>(std::move(reporting_context));
 }
 
+base::Value ReportingService::StatusAsValue() const {
+  NOTIMPLEMENTED();
+  return base::Value();
+}
+
 }  // namespace net
diff --git a/chromium/net/reporting/reporting_service.h b/chromium/net/reporting/reporting_service.h
index b165cdcdfc8..e30d122a331 100644
--- a/chromium/net/reporting/reporting_service.h
+++ b/chromium/net/reporting/reporting_service.h
@@ -67,12 +67,18 @@ class NET_EXPORT ReportingService {
       int data_type_mask,
       const base::RepeatingCallback<bool(const GURL&)>& origin_filter) = 0;
 
+  // Like RemoveBrowsingData except removes data for all origins without a
+  // filter.
+  virtual void RemoveAllBrowsingData(int data_type_mask) = 0;
+
   // Checks how many uploads deep |request| is: 0 if it's not an upload, n+1 if
   // it's an upload reporting on requests of at most depth n.
   virtual int GetUploadDepth(const URLRequest& request) = 0;
 
   virtual const ReportingPolicy& GetPolicy() const = 0;
 
+  virtual base::Value StatusAsValue() const;
+
  protected:
   ReportingService() {}
 
diff --git a/chromium/net/reporting/reporting_service_unittest.cc b/chromium/net/reporting/reporting_service_unittest.cc
index c0dd7fe5f60..4f5c5e6032a 100644
--- a/chromium/net/reporting/reporting_service_unittest.cc
+++ b/chromium/net/reporting/reporting_service_unittest.cc
@@ -16,12 +16,13 @@
 #include "net/reporting/reporting_report.h"
 #include "net/reporting/reporting_service.h"
 #include "net/reporting/reporting_test_util.h"
+#include "net/test/test_with_scoped_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
-class ReportingServiceTest : public ::testing::Test {
+class ReportingServiceTest : public TestWithScopedTaskEnvironment {
  protected:
   const GURL kUrl_ = GURL("https://origin/path");
   const url::Origin kOrigin_ = url::Origin::Create(kUrl_);
diff --git a/chromium/net/reporting/reporting_test_util.h b/chromium/net/reporting/reporting_test_util.h
index 239a2f42a83..b5edf6b0de4 100644
--- a/chromium/net/reporting/reporting_test_util.h
+++ b/chromium/net/reporting/reporting_test_util.h
@@ -16,6 +16,7 @@
 #include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_delegate.h"
 #include "net/reporting/reporting_uploader.h"
+#include "net/test/test_with_scoped_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class GURL;
@@ -171,7 +172,7 @@ class TestReportingContext : public ReportingContext {
 
 // A unit test base class that provides a TestReportingContext and shorthand
 // getters.
-class ReportingTestBase : public ::testing::Test {
+class ReportingTestBase : public TestWithScopedTaskEnvironment {
  protected:
   ReportingTestBase();
   ~ReportingTestBase() override;
diff --git a/chromium/net/reporting/reporting_uploader_unittest.cc b/chromium/net/reporting/reporting_uploader_unittest.cc
index e417b08dd91..7e29e265608 100644
--- a/chromium/net/reporting/reporting_uploader_unittest.cc
+++ b/chromium/net/reporting/reporting_uploader_unittest.cc
@@ -17,13 +17,14 @@
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
+#include "net/test/test_with_scoped_task_environment.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
-class ReportingUploaderTest : public ::testing::Test {
+class ReportingUploaderTest : public TestWithScopedTaskEnvironment {
  protected:
   ReportingUploaderTest()
       : server_(test_server::EmbeddedTestServer::TYPE_HTTPS),