BASELINE: Update Chromium to 84.0.4147.141

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

13 files changed, 148 insertions, 176 deletions

diff --git a/chromium/components/domain_reliability/context.cc b/chromium/components/domain_reliability/context.cc
index 2f09c115b02..d3084337475 100644
--- a/chromium/components/domain_reliability/context.cc
+++ b/chromium/components/domain_reliability/context.cc
@@ -18,7 +18,6 @@
 #include "components/domain_reliability/uploader.h"
 #include "components/domain_reliability/util.h"
 #include "net/base/net_errors.h"
-#include "net/url_request/url_request_context_getter.h"
 
 using base::DictionaryValue;
 using base::ListValue;
diff --git a/chromium/components/domain_reliability/google_configs.cc b/chromium/components/domain_reliability/google_configs.cc
index bc16304c73b..7de679f8840 100644
--- a/chromium/components/domain_reliability/google_configs.cc
+++ b/chromium/components/domain_reliability/google_configs.cc
@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include "base/strings/string_util.h"
 #include "net/base/url_util.h"
 
 namespace domain_reliability {
diff --git a/chromium/components/domain_reliability/monitor.cc b/chromium/components/domain_reliability/monitor.cc
index e896cf6cc42..788b22df909 100644
--- a/chromium/components/domain_reliability/monitor.cc
+++ b/chromium/components/domain_reliability/monitor.cc
@@ -8,11 +8,9 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/command_line.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/notreached.h"
 #include "components/domain_reliability/baked_in_configs.h"
 #include "components/domain_reliability/google_configs.h"
 #include "components/domain_reliability/quic_error_mapping.h"
@@ -21,7 +19,6 @@
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
 
 namespace domain_reliability {
 
@@ -55,14 +52,17 @@ std::unique_ptr<DomainReliabilityBeacon> CreateBeaconFromAttempt(
 }  // namespace
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
+    net::URLRequestContext* url_request_context,
     const std::string& upload_reporter_string,
     const DomainReliabilityContext::UploadAllowedCallback&
         upload_allowed_callback)
-    : DomainReliabilityMonitor(upload_reporter_string,
+    : DomainReliabilityMonitor(url_request_context,
+                               upload_reporter_string,
                                upload_allowed_callback,
                                std::make_unique<ActualTime>()) {}
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
+    net::URLRequestContext* url_request_context,
     const std::string& upload_reporter_string,
     const DomainReliabilityContext::UploadAllowedCallback&
         upload_allowed_callback,
@@ -74,6 +74,10 @@ DomainReliabilityMonitor::DomainReliabilityMonitor(
                        upload_allowed_callback,
                        &dispatcher_),
       discard_uploads_set_(false) {
+  DCHECK(url_request_context);
+  uploader_ =
+      DomainReliabilityUploader::Create(time_.get(), url_request_context);
+  context_manager_.SetUploader(uploader_.get());
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
@@ -81,24 +85,6 @@ DomainReliabilityMonitor::~DomainReliabilityMonitor() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
-void DomainReliabilityMonitor::InitURLRequestContext(
-    net::URLRequestContext* url_request_context) {
-  DCHECK(url_request_context);
-
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
-      new net::TrivialURLRequestContextGetter(
-          url_request_context, base::ThreadTaskRunnerHandle::Get());
-  InitURLRequestContext(url_request_context_getter);
-}
-
-void DomainReliabilityMonitor::InitURLRequestContext(
-    const scoped_refptr<net::URLRequestContextGetter>&
-        url_request_context_getter) {
-  uploader_ = DomainReliabilityUploader::Create(time_.get(),
-                                                url_request_context_getter);
-  context_manager_.SetUploader(uploader_.get());
-}
-
 void DomainReliabilityMonitor::Shutdown() {
   uploader_->Shutdown();
 }
@@ -220,7 +206,10 @@ DomainReliabilityMonitor::RequestInfo::~RequestInfo() {}
 // static
 bool DomainReliabilityMonitor::RequestInfo::ShouldReportRequest(
     const DomainReliabilityMonitor::RequestInfo& request) {
-  // Always report upload requests, even though they have DO_NOT_SEND_COOKIES.
+  // Always report DR upload requests, even though they have
+  // DO_NOT_SEND_COOKIES.
+  // Note: They are reported (i.e. generate a beacon) but do not necessarily
+  // trigger an upload by themselves.
   if (request.upload_depth > 0)
     return true;
 
diff --git a/chromium/components/domain_reliability/monitor.h b/chromium/components/domain_reliability/monitor.h
index 8d5582d5d09..47e6c4c32b7 100644
--- a/chromium/components/domain_reliability/monitor.h
+++ b/chromium/components/domain_reliability/monitor.h
@@ -38,15 +38,14 @@ class Value;
 namespace net {
 class URLRequest;
 class URLRequestContext;
-class URLRequestContextGetter;
 }  // namespace net
 
 namespace domain_reliability {
 
 // The top-level object that measures requests and hands off the measurements
 // to the proper |DomainReliabilityContext|.
-// To initialize this object fully, you need to call InitURLRequestContext(),
-// AddBakedInConfigs(), and SetDiscardUploads() before using this.
+// To initialize this object fully, you need to call AddBakedInConfigs() and
+// SetDiscardUploads() before using this.
 class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
     : public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
@@ -71,12 +70,14 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
 
   // Creates a Monitor.
   DomainReliabilityMonitor(
+      net::URLRequestContext* url_request_context,
       const std::string& upload_reporter_string,
       const DomainReliabilityContext::UploadAllowedCallback&
           upload_allowed_callback);
 
   // Same, but specifies a mock interface for time functions for testing.
   DomainReliabilityMonitor(
+      net::URLRequestContext* url_request_context,
       const std::string& upload_reporter_string,
       const DomainReliabilityContext::UploadAllowedCallback&
           upload_allowed_callback,
@@ -84,14 +85,6 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
 
   ~DomainReliabilityMonitor() override;
 
-  // Initializes the Monitor's URLRequestContextGetter.
-  void InitURLRequestContext(net::URLRequestContext* url_request_context);
-
-  // Same, but for unittests where the Getter is readily available.
-  void InitURLRequestContext(
-      const scoped_refptr<net::URLRequestContextGetter>&
-          url_request_context_getter);
-
   // Shuts down the monitor prior to destruction. Currently, ensures that there
   // are no pending uploads, to avoid hairy lifetime issues at destruction.
   void Shutdown();
@@ -101,8 +94,7 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
   // on demand at runtime.
   void AddBakedInConfigs();
 
-  // Sets whether the uploader will discard uploads. Must be called after
-  // |InitURLRequestContext|.
+  // Sets whether the uploader will discard uploads.
   void SetDiscardUploads(bool discard_uploads);
 
   // Should be called when |request| is about to follow a redirect. Will
diff --git a/chromium/components/domain_reliability/monitor_unittest.cc b/chromium/components/domain_reliability/monitor_unittest.cc
index 16b758adb34..bfaa18af183 100644
--- a/chromium/components/domain_reliability/monitor_unittest.cc
+++ b/chromium/components/domain_reliability/monitor_unittest.cc
@@ -15,7 +15,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/string_piece.h"
-#include "base/test/test_simple_task_runner.h"
+#include "base/test/task_environment.h"
 #include "components/domain_reliability/baked_in_configs.h"
 #include "components/domain_reliability/beacon.h"
 #include "components/domain_reliability/config.h"
@@ -25,7 +25,6 @@
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -54,14 +53,11 @@ class DomainReliabilityMonitorTest : public testing::Test {
   typedef DomainReliabilityMonitor::RequestInfo RequestInfo;
 
   DomainReliabilityMonitorTest()
-      : network_task_runner_(new base::TestSimpleTaskRunner()),
-        url_request_context_getter_(
-            new net::TestURLRequestContextGetter(network_task_runner_)),
-        time_(new MockTime()),
-        monitor_("test-reporter",
+      : time_(new MockTime()),
+        monitor_(&url_request_context_,
+                 "test-reporter",
                  DomainReliabilityContext::UploadAllowedCallback(),
                  std::unique_ptr<MockableTime>(time_)) {
-    monitor_.InitURLRequestContext(url_request_context_getter_);
     monitor_.SetDiscardUploads(false);
   }
 
@@ -108,8 +104,8 @@ class DomainReliabilityMonitorTest : public testing::Test {
     return monitor_.AddContextForTesting(std::move(config));
   }
 
-  scoped_refptr<base::TestSimpleTaskRunner> network_task_runner_;
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
+  base::test::SingleThreadTaskEnvironment task_environment_;
+  net::TestURLRequestContext url_request_context_;
   MockTime* time_;
   DomainReliabilityMonitor monitor_;
   DomainReliabilityMonitor::RequestInfo request_;
diff --git a/chromium/components/domain_reliability/quic_error_mapping.cc b/chromium/components/domain_reliability/quic_error_mapping.cc
index ea7168a6d38..46562b479c2 100644
--- a/chromium/components/domain_reliability/quic_error_mapping.cc
+++ b/chromium/components/domain_reliability/quic_error_mapping.cc
@@ -366,6 +366,8 @@ const struct QuicErrorMapping {
      "quic.http_missing_settings_frame"},
     {quic::QUIC_HTTP_DUPLICATE_SETTING_IDENTIFIER,
      "quic.http_duplicate_setting_identifier"},
+    {quic::QUIC_HTTP_INVALID_MAX_PUSH_ID, "quic.http_invalid_max_push_id"},
+    {quic::QUIC_HTTP_STREAM_LIMIT_TOO_LOW, "quic.http_stream_limit_too_low"},
 
     // QUIC_INVALID_APPLICATION_CLOSE_DATA was code 101. The code has been
     // deprecated, but to keep the assert below happy, there needs to be
diff --git a/chromium/components/domain_reliability/test_util.cc b/chromium/components/domain_reliability/test_util.cc
index 4ece75a227c..a296c52b6af 100644
--- a/chromium/components/domain_reliability/test_util.cc
+++ b/chromium/components/domain_reliability/test_util.cc
@@ -99,6 +99,8 @@ void MockUploader::UploadReport(const std::string& report_json,
                            std::move(callback));
 }
 
+void MockUploader::Shutdown() {}
+
 void MockUploader::SetDiscardUploads(bool discard_uploads) {
   discard_uploads_ = discard_uploads;
 }
diff --git a/chromium/components/domain_reliability/test_util.h b/chromium/components/domain_reliability/test_util.h
index 06e7841473d..11c2505ae66 100644
--- a/chromium/components/domain_reliability/test_util.h
+++ b/chromium/components/domain_reliability/test_util.h
@@ -50,14 +50,12 @@ class MockUploader : public DomainReliabilityUploader {
   virtual bool discard_uploads() const;
 
   // DomainReliabilityUploader implementation:
-
   void UploadReport(const std::string& report_json,
                     int max_upload_depth,
                     const GURL& upload_url,
                     UploadCallback callback) override;
-
+  void Shutdown() override;
   void SetDiscardUploads(bool discard_uploads) override;
-
   int GetDiscardedUploadCount() const override;
 
  private:
diff --git a/chromium/components/domain_reliability/uploader.cc b/chromium/components/domain_reliability/uploader.cc
index 17faa83e69f..159526609b6 100644
--- a/chromium/components/domain_reliability/uploader.cc
+++ b/chromium/components/domain_reliability/uploader.cc
@@ -6,21 +6,19 @@
 
 #include <utility>
 
-#include "base/bind.h"
 #include "base/callback.h"
+#include "base/containers/unique_ptr_adapters.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_functions.h"
 #include "base/supports_user_data.h"
 #include "components/domain_reliability/util.h"
-#include "net/base/load_flags.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_errors.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
-#include "net/url_request/url_fetcher.h"
-#include "net/url_request/url_fetcher_delegate.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 
 namespace domain_reliability {
 
@@ -28,43 +26,40 @@ namespace {
 
 const char kJsonMimeType[] = "application/json; charset=utf-8";
 
-class UploadUserData : public base::SupportsUserData::Data {
- public:
-  static net::URLFetcher::CreateDataCallback CreateCreateDataCallback(
-      int depth) {
-    return base::BindRepeating(&UploadUserData::CreateUploadUserData, depth);
-  }
+// Each DR upload is tagged with an instance of this class, which identifies the
+// depth of the upload. This is to prevent infinite loops of DR uploads about DR
+// uploads, leading to an unbounded number of requests.
+// Deeper requests will still generate a report beacon, but they won't trigger a
+// separate upload. See DomainReliabilityContext::kMaxUploadDepthToSchedule.
+struct UploadDepthData : public base::SupportsUserData::Data {
+  explicit UploadDepthData(int depth) : depth(depth) {}
 
+  // Key that identifies this data within SupportsUserData's map of data.
   static const void* const kUserDataKey;
 
-  int depth() const { return depth_; }
-
- private:
-  UploadUserData(int depth) : depth_(depth) {}
-
-  static std::unique_ptr<base::SupportsUserData::Data> CreateUploadUserData(
-      int depth) {
-    return base::WrapUnique(new UploadUserData(depth));
-  }
-
-  int depth_;
+  // This is 0 if the report being uploaded does not contain a beacon about a
+  // DR upload request. Otherwise, it is 1 + the depth of the deepest DR upload
+  // described in the report.
+  int depth;
 };
 
-const void* const UploadUserData::kUserDataKey =
-    &UploadUserData::kUserDataKey;
+const void* const UploadDepthData::kUserDataKey =
+    &UploadDepthData::kUserDataKey;
+
+}  // namespace
 
-class DomainReliabilityUploaderImpl
-    : public DomainReliabilityUploader, net::URLFetcherDelegate {
+class DomainReliabilityUploaderImpl : public DomainReliabilityUploader,
+                                      public net::URLRequest::Delegate {
  public:
-  DomainReliabilityUploaderImpl(
-      MockableTime* time,
-      const scoped_refptr<net::URLRequestContextGetter>&
-          url_request_context_getter)
+  DomainReliabilityUploaderImpl(MockableTime* time,
+                                net::URLRequestContext* url_request_context)
       : time_(time),
-        url_request_context_getter_(url_request_context_getter),
+        url_request_context_(url_request_context),
         discard_uploads_(true),
         shutdown_(false),
-        discarded_upload_count_(0u) {}
+        discarded_upload_count_(0u) {
+    DCHECK(url_request_context_);
+  }
 
   ~DomainReliabilityUploaderImpl() override {
     DCHECK(shutdown_);
@@ -116,19 +111,29 @@ class DomainReliabilityUploaderImpl
               "data to Google'."
             policy_exception_justification: "Not implemented."
           })");
-    std::unique_ptr<net::URLFetcher> owned_fetcher = net::URLFetcher::Create(
-        0, upload_url, net::URLFetcher::POST, this, traffic_annotation);
-    net::URLFetcher* fetcher = owned_fetcher.get();
-    fetcher->SetRequestContext(url_request_context_getter_.get());
-    fetcher->SetAllowCredentials(false);
-    fetcher->SetUploadData(kJsonMimeType, report_json);
-    fetcher->SetAutomaticallyRetryOn5xx(false);
-    fetcher->SetURLRequestUserData(
-        UploadUserData::kUserDataKey,
-        UploadUserData::CreateCreateDataCallback(max_upload_depth + 1));
-    fetcher->Start();
-
-    uploads_[fetcher] = {std::move(owned_fetcher), std::move(callback)};
+    std::unique_ptr<net::URLRequest> request =
+        url_request_context_->CreateRequest(
+            upload_url, net::RequestPriority::IDLE, this /* delegate */,
+            traffic_annotation);
+    request->set_method("POST");
+    request->set_allow_credentials(false);
+    request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
+                                         kJsonMimeType, true /* overwrite */);
+    std::vector<char> report_data(report_json.begin(), report_json.end());
+    auto upload_reader =
+        std::make_unique<net::UploadOwnedBytesElementReader>(&report_data);
+    request->set_upload(net::ElementsUploadDataStream::CreateWithReader(
+        std::move(upload_reader), 0 /* identifier */));
+    request->SetUserData(
+        UploadDepthData::kUserDataKey,
+        std::make_unique<UploadDepthData>(max_upload_depth + 1));
+
+    UploadMap::iterator it;
+    bool inserted;
+    std::tie(it, inserted) = uploads_.insert(
+        std::make_pair(std::move(request), std::move(callback)));
+    DCHECK(inserted);
+    it->first->Start();
   }
 
   void SetDiscardUploads(bool discard_uploads) override {
@@ -146,24 +151,22 @@ class DomainReliabilityUploaderImpl
     return discarded_upload_count_;
   }
 
-  // net::URLFetcherDelegate implementation:
-  void OnURLFetchComplete(const net::URLFetcher* fetcher) override {
-    DCHECK(fetcher);
+  // net::URLRequest::Delegate implementation:
+  void OnResponseStarted(net::URLRequest* request, int net_error) override {
+    DCHECK(!shutdown_);
 
-    auto callback_it = uploads_.find(fetcher);
-    DCHECK(callback_it != uploads_.end());
+    auto request_it = uploads_.find(request);
+    DCHECK(request_it != uploads_.end());
 
-    int net_error = GetNetErrorFromURLRequestStatus(fetcher->GetStatus());
-    int http_response_code = fetcher->GetResponseCode();
+    int http_response_code = -1;
     base::TimeDelta retry_after;
-    {
+    if (net_error == net::OK) {
+      http_response_code = request->GetResponseCode();
       std::string retry_after_string;
-      if (fetcher->GetResponseHeaders() &&
-          fetcher->GetResponseHeaders()->EnumerateHeader(nullptr,
-                                                         "Retry-After",
-                                                         &retry_after_string)) {
-        net::HttpUtil::ParseRetryAfterHeader(retry_after_string,
-                                             time_->Now(),
+      if (request->response_headers() &&
+          request->response_headers()->EnumerateHeader(nullptr, "Retry-After",
+                                                       &retry_after_string)) {
+        net::HttpUtil::ParseRetryAfterHeader(retry_after_string, time_->Now(),
                                              &retry_after);
       }
     }
@@ -172,53 +175,49 @@ class DomainReliabilityUploaderImpl
              << ", response code " << http_response_code << ", retry after "
              << retry_after;
 
-    UploadResult result;
-    GetUploadResultFromResponseDetails(net_error,
-                                       http_response_code,
-                                       retry_after,
-                                       &result);
-    std::move(callback_it->second.second).Run(result);
+    std::move(request_it->second)
+        .Run(GetUploadResultFromResponseDetails(net_error, http_response_code,
+                                                retry_after));
+    uploads_.erase(request_it);
+  }
 
-    uploads_.erase(callback_it);
+  // Requests are cancelled in OnResponseStarted() once response headers are
+  // read, without reading the body, so this is not needed.
+  void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
+    NOTREACHED();
   }
 
  private:
-  using DomainReliabilityUploader::UploadCallback;
-
   MockableTime* time_;
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
-  std::map<const net::URLFetcher*,
-           std::pair<std::unique_ptr<net::URLFetcher>, UploadCallback>>
-      uploads_;
+  net::URLRequestContext* url_request_context_;
+  // Stores each in-flight upload request with the callback to notify its
+  // initiating DRContext of its completion.
+  using UploadMap = std::map<std::unique_ptr<net::URLRequest>,
+                             UploadCallback,
+                             base::UniquePtrComparator>;
+  UploadMap uploads_;
   bool discard_uploads_;
   bool shutdown_;
   int discarded_upload_count_;
 };
 
-}  // namespace
-
 DomainReliabilityUploader::DomainReliabilityUploader() {}
 DomainReliabilityUploader::~DomainReliabilityUploader() {}
 
 // static
 std::unique_ptr<DomainReliabilityUploader> DomainReliabilityUploader::Create(
     MockableTime* time,
-    const scoped_refptr<net::URLRequestContextGetter>&
-        url_request_context_getter) {
-  return std::unique_ptr<DomainReliabilityUploader>(
-      new DomainReliabilityUploaderImpl(time, url_request_context_getter));
+    net::URLRequestContext* url_request_context) {
+  return std::make_unique<DomainReliabilityUploaderImpl>(time,
+                                                         url_request_context);
 }
 
 // static
 int DomainReliabilityUploader::GetURLRequestUploadDepth(
     const net::URLRequest& request) {
-  UploadUserData* data = static_cast<UploadUserData*>(
-      request.GetUserData(UploadUserData::kUserDataKey));
-  if (!data)
-    return 0;
-  return data->depth();
+  UploadDepthData* data = static_cast<UploadDepthData*>(
+      request.GetUserData(UploadDepthData::kUserDataKey));
+  return data ? data->depth : 0;
 }
 
-void DomainReliabilityUploader::Shutdown() {}
-
 }  // namespace domain_reliability
diff --git a/chromium/components/domain_reliability/uploader.h b/chromium/components/domain_reliability/uploader.h
index 9c617fef143..4e2e56ca066 100644
--- a/chromium/components/domain_reliability/uploader.h
+++ b/chromium/components/domain_reliability/uploader.h
@@ -16,7 +16,7 @@
 
 namespace net {
 class URLRequest;
-class URLRequestContextGetter;
+class URLRequestContext;
 }  // namespace net
 
 namespace domain_reliability {
@@ -41,19 +41,17 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityUploader {
     base::TimeDelta retry_after;
   };
 
-  typedef base::OnceCallback<void(const UploadResult& result)> UploadCallback;
+  using UploadCallback = base::OnceCallback<void(const UploadResult& result)>;
 
   DomainReliabilityUploader();
 
   virtual ~DomainReliabilityUploader();
 
-  // Creates an uploader that uses the given |url_request_context_getter| to
-  // get a URLRequestContext to use for uploads. (See test_util.h for a mock
-  // version.)
+  // Creates an uploader that uses the given |url_request_context| for uploads.
+  // (See test_util.h for a mock version.)
   static std::unique_ptr<DomainReliabilityUploader> Create(
       MockableTime* time,
-      const scoped_refptr<net::URLRequestContextGetter>&
-          url_request_context_getter);
+      net::URLRequestContext* url_request_context);
 
   // Uploads |report_json| to |upload_url| and calls |callback| when the upload
   // has either completed or failed.
@@ -65,7 +63,7 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityUploader {
   // Shuts down the uploader prior to destruction. Currently, terminates pending
   // uploads and prevents the uploader from starting new ones to avoid hairy
   // lifetime issues at destruction.
-  virtual void Shutdown();
+  virtual void Shutdown() = 0;
 
   // Sets whether the uploader will discard uploads but pretend they succeeded.
   // In Chrome, this is used when the user has not opted in to metrics
diff --git a/chromium/components/domain_reliability/uploader_unittest.cc b/chromium/components/domain_reliability/uploader_unittest.cc
index cd5396444c2..8c918c2a634 100644
--- a/chromium/components/domain_reliability/uploader_unittest.cc
+++ b/chromium/components/domain_reliability/uploader_unittest.cc
@@ -91,7 +91,7 @@ class UploadMockURLRequestJob : public net::URLRequestJob {
     if (result_.net_error == net::OK)
       NotifyHeadersComplete();
     else if (result_.net_error != net::ERR_IO_PENDING)
-      NotifyStartError(net::URLRequestStatus::FromError(result_.net_error));
+      NotifyStartError(result_.net_error);
   }
 
   void GetResponseInfo(net::HttpResponseInfo* info) override {
@@ -175,14 +175,12 @@ class TestUploadCallback {
 class DomainReliabilityUploaderTest : public testing::Test {
  protected:
   DomainReliabilityUploaderTest()
-      : url_request_context_getter_(new net::TestURLRequestContextGetter(
-            base::ThreadTaskRunnerHandle::Get())),
-        interceptor_(new UploadInterceptor()),
-        uploader_(
-            DomainReliabilityUploader::Create(&time_,
-                                              url_request_context_getter_)) {
+      : uploader_(
+            DomainReliabilityUploader::Create(&time_, &url_request_context_)) {
+    auto interceptor = std::make_unique<UploadInterceptor>();
+    interceptor_ = interceptor.get();
     net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-        GURL(kUploadURL), base::WrapUnique(interceptor_));
+        GURL(kUploadURL), std::move(interceptor));
     uploader_->SetDiscardUploads(false);
   }
 
@@ -192,14 +190,14 @@ class DomainReliabilityUploaderTest : public testing::Test {
 
   DomainReliabilityUploader* uploader() const { return uploader_.get(); }
   UploadInterceptor* interceptor() const { return interceptor_; }
-  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter() {
-    return url_request_context_getter_;
+  net::TestURLRequestContext* url_request_context() {
+    return &url_request_context_;
   }
 
  private:
   base::test::SingleThreadTaskEnvironment task_environment_{
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
-  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
+  net::TestURLRequestContext url_request_context_;
   UploadInterceptor* interceptor_;
   MockTime time_;
   std::unique_ptr<DomainReliabilityUploader> uploader_;
@@ -297,7 +295,7 @@ TEST_F(DomainReliabilityUploaderTest, UploadCanceledAtShutdown) {
 
   EXPECT_EQ(0u, c.called_count());
 
-  url_request_context_getter()->GetURLRequestContext()->AssertNoURLRequests();
+  url_request_context()->AssertNoURLRequests();
 }
 
 TEST_F(DomainReliabilityUploaderTest, NoUploadAfterShutdown) {
diff --git a/chromium/components/domain_reliability/util.cc b/chromium/components/domain_reliability/util.cc
index 94bb7c1f730..0e662c9b901 100644
--- a/chromium/components/domain_reliability/util.cc
+++ b/chromium/components/domain_reliability/util.cc
@@ -7,8 +7,8 @@
 #include <stddef.h>
 
 #include "base/callback.h"
-#include "base/logging.h"
 #include "base/memory/weak_ptr.h"
+#include "base/notreached.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
@@ -132,26 +132,25 @@ int GetNetErrorFromURLRequestStatus(const net::URLRequestStatus& status) {
   }
 }
 
-void GetUploadResultFromResponseDetails(
+DomainReliabilityUploader::UploadResult GetUploadResultFromResponseDetails(
     int net_error,
     int http_response_code,
-    base::TimeDelta retry_after,
-    DomainReliabilityUploader::UploadResult* result) {
+    base::TimeDelta retry_after) {
+  DomainReliabilityUploader::UploadResult result;
   if (net_error == net::OK && http_response_code == 200) {
-    result->status = DomainReliabilityUploader::UploadResult::SUCCESS;
-    return;
+    result.status = DomainReliabilityUploader::UploadResult::SUCCESS;
+    return result;
   }
 
-  if (net_error == net::OK &&
-      http_response_code == 503 &&
+  if (net_error == net::OK && http_response_code == 503 &&
       !retry_after.is_zero()) {
-    result->status = DomainReliabilityUploader::UploadResult::RETRY_AFTER;
-    result->retry_after = retry_after;
-    return;
+    result.status = DomainReliabilityUploader::UploadResult::RETRY_AFTER;
+    result.retry_after = retry_after;
+    return result;
   }
 
-  result->status = DomainReliabilityUploader::UploadResult::FAILURE;
-  return;
+  result.status = DomainReliabilityUploader::UploadResult::FAILURE;
+  return result;
 }
 
 // N.B. This uses a std::vector<std::unique_ptr<>> because that's what
diff --git a/chromium/components/domain_reliability/util.h b/chromium/components/domain_reliability/util.h
index f73894cc685..244134379a8 100644
--- a/chromium/components/domain_reliability/util.h
+++ b/chromium/components/domain_reliability/util.h
@@ -46,12 +46,11 @@ std::string GetDomainReliabilityProtocol(
 int GetNetErrorFromURLRequestStatus(const net::URLRequestStatus& status);
 
 // Based on the network error code, HTTP response code, and Retry-After value,
-// fills |status| with the result of a report upload.
-void GetUploadResultFromResponseDetails(
+// returns the result of a report upload.
+DomainReliabilityUploader::UploadResult GetUploadResultFromResponseDetails(
     int net_error,
     int http_response_code,
-    base::TimeDelta retry_after,
-    DomainReliabilityUploader::UploadResult* result);
+    base::TimeDelta retry_after);
 
 GURL SanitizeURLForReport(
     const GURL& beacon_url,