Reland "Remove remaining components/domain_reliability dependency on content/...

Reland "Remove remaining components/domain_reliability dependency on content/ and components/keyed_service."

This is a reland of bd611e3e

Original change's description:
> Remove remaining components/domain_reliability dependency on content/ and components/keyed_service.
>
> This way it can run in the network process, similar to Network Error Logging.
>
> Bug: 853251
> Change-Id: I403a5dcc3cae12b592a444c7e23f71c552b58e1f
> Reviewed-on: https://chromium-review.googlesource.com/c/1334848
> Reviewed-by: Misha Efimov <mef@chromium.org>
> Commit-Queue: John Abd-El-Malek <jam@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#608175}

TBR=mef@chromium.org

Bug: 853251
Change-Id: Iee089ae0cd422e242df53604da6dcb8ef25b74cb
Reviewed-on: https://chromium-review.googlesource.com/c/1337373Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Commit-Queue: John Abd-El-Malek <jam@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608281}

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

@@ -140,6 +140,7 @@ using content::BrowsingDataFilterBuilder;
 using domain_reliability::CLEAR_BEACONS;
 using domain_reliability::CLEAR_CONTEXTS;
 using domain_reliability::DomainReliabilityClearMode;
+using domain_reliability::DomainReliabilityKeyedServiceWrapper;
 using domain_reliability::DomainReliabilityMonitor;
 using domain_reliability::DomainReliabilityService;
 using domain_reliability::DomainReliabilityServiceFactory;
@@ -496,8 +497,9 @@ class MockDomainReliabilityService : public DomainReliabilityService {
 
   std::unique_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
-      override {
+      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+      const domain_reliability::DomainReliabilityContext::UploadAllowedCallback&
+          upload_allowed_callback) override {
     NOTREACHED();
     return std::unique_ptr<DomainReliabilityMonitor>();
   }
@@ -578,7 +580,7 @@ std::unique_ptr<KeyedService> TestingDomainReliabilityServiceFactoryFunction(
   EXPECT_FALSE(data->attached);
 
   data->attached = true;
-  return base::WrapUnique(data->service);
+  return std::make_unique<DomainReliabilityKeyedServiceWrapper>(data->service);
 }
 
 std::unique_ptr<KeyedService> BuildProtocolHandlerRegistry(
@@ -590,20 +592,19 @@ std::unique_ptr<KeyedService> BuildProtocolHandlerRegistry(
 
 class ClearDomainReliabilityTester {
  public:
-  explicit ClearDomainReliabilityTester(TestingProfile* profile) :
-      profile_(profile),
-      mock_service_(new MockDomainReliabilityService()) {
+  explicit ClearDomainReliabilityTester(TestingProfile* profile)
+      : profile_(profile) {
     AttachService();
   }
 
-  unsigned clear_count() const { return mock_service_->clear_count(); }
+  unsigned clear_count() const { return mock_service_.clear_count(); }
 
   DomainReliabilityClearMode last_clear_mode() const {
-    return mock_service_->last_clear_mode();
+    return mock_service_.last_clear_mode();
   }
 
   const base::Callback<bool(const GURL&)>& last_filter() const {
-    return mock_service_->last_filter();
+    return mock_service_.last_filter();
   }
 
  private:
@@ -613,7 +614,7 @@ class ClearDomainReliabilityTester {
     // Attach kludgey UserData struct to profile.
     TestingDomainReliabilityServiceFactoryUserData* data =
         new TestingDomainReliabilityServiceFactoryUserData(profile_,
-                                                           mock_service_);
+                                                           &mock_service_);
     EXPECT_FALSE(profile_->GetUserData(kKey));
     profile_->SetUserData(kKey, base::WrapUnique(data));
 
@@ -629,7 +630,7 @@ class ClearDomainReliabilityTester {
   }
 
   TestingProfile* profile_;
-  MockDomainReliabilityService* mock_service_;
+  MockDomainReliabilityService mock_service_;
 };
 
 class RemovePasswordsTester {

chrome/browser/domain_reliability/service_factory.cc

@@ -33,13 +33,22 @@ const char kUploadReporterString[] = "chrome";
 
 }  // namespace
 
+DomainReliabilityKeyedServiceWrapper::DomainReliabilityKeyedServiceWrapper(
+    DomainReliabilityService* service)
+    : service_(service) {}
+DomainReliabilityKeyedServiceWrapper::~DomainReliabilityKeyedServiceWrapper() =
+    default;
+
 // static
 DomainReliabilityService*
 DomainReliabilityServiceFactory::GetForBrowserContext(
     content::BrowserContext* context) {
-  return static_cast<DomainReliabilityService*>(
+  auto* wrapper = static_cast<DomainReliabilityKeyedServiceWrapper*>(
       GetInstance()->GetServiceForBrowserContext(context,
                                                  /* create = */ true));
+  if (!wrapper)
+    return nullptr;
+  return wrapper->service();
 }
 
 // static
@@ -60,7 +69,8 @@ KeyedService* DomainReliabilityServiceFactory::BuildServiceInstanceFor(
   if (!ShouldCreateService())
     return NULL;
 
-  return DomainReliabilityService::Create(kUploadReporterString, context);
+  return new DomainReliabilityKeyedServiceWrapper(
+      DomainReliabilityService::Create(kUploadReporterString));
 }
 
 bool DomainReliabilityServiceFactory::ShouldCreateService() const {

chrome/browser/domain_reliability/service_factory.h

@@ -8,6 +8,7 @@
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+#include "components/keyed_service/core/keyed_service.h"
 
 namespace content {
 class BrowserContext;
@@ -17,6 +18,20 @@ namespace domain_reliability {
 
 class DomainReliabilityService;
 
+class DomainReliabilityKeyedServiceWrapper : public KeyedService {
+ public:
+  explicit DomainReliabilityKeyedServiceWrapper(
+      DomainReliabilityService* service);
+  ~DomainReliabilityKeyedServiceWrapper() override;
+
+  DomainReliabilityService* service() { return service_; }
+
+ private:
+  DomainReliabilityService* service_;
+
+  DISALLOW_COPY_AND_ASSIGN(DomainReliabilityKeyedServiceWrapper);
+};
+
 // Creates DomainReliabilityServices for BrowserContexts. Initializes them with
 // the hardcoded upload reporter string "chrome".
 class DomainReliabilityServiceFactory

chrome/browser/profiles/profile_impl.cc

@@ -123,6 +123,8 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/permission_controller.h"
+#include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/url_data_source.h"
@@ -326,6 +328,31 @@ std::unique_ptr<service_manager::Service> CreateAppService(Profile* profile) {
 }
 #endif
 
+void CheckDomainReliablityUploadAllowedOnUIThread(
+    Profile* profile,
+    const GURL& origin,
+    base::OnceCallback<void(bool)> callback) {
+  // Profile is safe since ProfileImpl always outlives IO thread.
+  content::PermissionController* permission_controller =
+      content::BrowserContext::GetPermissionController(profile);
+  DCHECK(permission_controller);
+  bool allowed = permission_controller->GetPermissionStatus(
+                     content::PermissionType::BACKGROUND_SYNC, origin,
+                     origin) == blink::mojom::PermissionStatus::GRANTED;
+  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::IO},
+                           base::BindOnce(std::move(callback), allowed));
+}
+
+void CheckDomainReliablityUploadAllowedOnIOThread(
+    Profile* profile,
+    const GURL& origin,
+    base::OnceCallback<void(bool)> callback) {
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::UI},
+      base::BindOnce(CheckDomainReliablityUploadAllowedOnUIThread, profile,
+                     origin, std::move(callback)));
+}
+
 }  // namespace
 
 // static
@@ -1476,7 +1503,8 @@ ProfileImpl::CreateDomainReliabilityMonitor(PrefService* local_state) {
 
   return service->CreateMonitor(
       base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::UI}),
-      base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO}));
+      base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO}),
+      base::BindRepeating(CheckDomainReliablityUploadAllowedOnIOThread, this));
 }
 
 std::unique_ptr<service_manager::Service> ProfileImpl::CreateIdentityService() {

chrome/browser/profiles/profile_impl_io_data.cc

@@ -174,7 +174,8 @@ void ProfileImplIOData::Handle::Init(
 
   io_data_->InitializeMetricsEnabledStateOnUIThread();
   if (io_data_->lazy_params_->domain_reliability_monitor)
-    io_data_->lazy_params_->domain_reliability_monitor->MoveToNetworkThread();
+    io_data_->lazy_params_->domain_reliability_monitor
+        ->InitializeOnNetworkThread();
 
   io_data_->set_data_reduction_proxy_io_data(
       CreateDataReductionProxyChromeIOData(

components/domain_reliability/BUILD.gn

@@ -86,9 +86,6 @@ jumbo_component("domain_reliability") {
   deps = [
     ":bake_in_configs",
     "//base",
-    "//components/keyed_service/core",
-    "//content/public/browser",
-    "//content/public/common",
     "//net",
     "//url",
   ]
@@ -117,8 +114,6 @@ jumbo_source_set("unit_tests") {
     ":domain_reliability",
     "//base",
     "//base/test:test_support",
-    "//content/public/browser",
-    "//content/test:test_support",
     "//net:test_support",
     "//testing/gtest",
   ]

components/domain_reliability/DEPS

@@ -4,9 +4,5 @@
 
 include_rules = [
   "+net",
-  "+components/keyed_service/core",
-  "+content/public/browser",
-  "+content/public/test",
-  "+third_party/blink/public",
 ]
 

components/domain_reliability/monitor.cc

@@ -78,7 +78,7 @@ DomainReliabilityMonitor::DomainReliabilityMonitor(
     const std::string& upload_reporter_string,
     const DomainReliabilityContext::UploadAllowedCallback&
         upload_allowed_callback,
-    const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& network_thread)
     : time_(new ActualTime()),
       upload_reporter_string_(upload_reporter_string),
@@ -87,19 +87,19 @@ DomainReliabilityMonitor::DomainReliabilityMonitor(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       context_manager_(this),
-      pref_task_runner_(pref_thread),
+      main_task_runner_(main_thread),
       network_task_runner_(network_thread),
       moved_to_network_thread_(false),
       discard_uploads_set_(false),
       weak_factory_(this) {
-  DCHECK(OnPrefThread());
+  DCHECK(OnMainThread());
 }
 
 DomainReliabilityMonitor::DomainReliabilityMonitor(
     const std::string& upload_reporter_string,
     const DomainReliabilityContext::UploadAllowedCallback&
         upload_allowed_callback,
-    const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& network_thread,
     std::unique_ptr<MockableTime> time)
     : time_(std::move(time)),
@@ -109,12 +109,12 @@ DomainReliabilityMonitor::DomainReliabilityMonitor(
           DomainReliabilityScheduler::Params::GetFromFieldTrialsOrDefaults()),
       dispatcher_(time_.get()),
       context_manager_(this),
-      pref_task_runner_(pref_thread),
+      main_task_runner_(main_thread),
       network_task_runner_(network_thread),
       moved_to_network_thread_(false),
       discard_uploads_set_(false),
       weak_factory_(this) {
-  DCHECK(OnPrefThread());
+  DCHECK(OnMainThread());
 }
 
 DomainReliabilityMonitor::~DomainReliabilityMonitor() {
@@ -122,12 +122,12 @@ DomainReliabilityMonitor::~DomainReliabilityMonitor() {
     net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
     DCHECK(OnNetworkThread());
   } else {
-    DCHECK(OnPrefThread());
+    DCHECK(OnMainThread());
   }
 }
 
-void DomainReliabilityMonitor::MoveToNetworkThread() {
-  DCHECK(OnPrefThread());
+void DomainReliabilityMonitor::InitializeOnNetworkThread() {
+  DCHECK(OnMainThread());
   DCHECK(!moved_to_network_thread_);
 
   network_task_runner_->PostTask(

components/domain_reliability/monitor.h

@@ -51,14 +51,14 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
     : public net::NetworkChangeNotifier::NetworkChangeObserver,
       DomainReliabilityContext::Factory {
  public:
-  // Creates a Monitor. |local_state_pref_service| must live on |pref_thread|
-  // (which should be the current thread); |network_thread| is the thread
+  // Creates a Monitor. |main_thread| is the current thread, which may or may
+  // not be the same as |network_thread|. |network_thread| is the thread
   // on which requests will actually be monitored and reported.
   DomainReliabilityMonitor(
       const std::string& upload_reporter_string,
       const DomainReliabilityContext::UploadAllowedCallback&
           upload_allowed_callback,
-      const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& network_thread);
 
   // Same, but specifies a mock interface for time functions for testing.
@@ -66,25 +66,25 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
       const std::string& upload_reporter_string,
       const DomainReliabilityContext::UploadAllowedCallback&
           upload_allowed_callback,
-      const scoped_refptr<base::SingleThreadTaskRunner>& pref_thread,
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& network_thread,
       std::unique_ptr<MockableTime> time);
 
-  // Must be called from the pref thread if |MoveToNetworkThread| was not
+  // Must be called from the main thread if |InitializeOnNetworkThread| was not
   // called, or from the network thread if it was called.
   ~DomainReliabilityMonitor() override;
 
   // Must be called before |InitURLRequestContext| on the same thread on which
   // the Monitor was constructed. Moves (most of) the Monitor to the network
   // thread passed in the constructor.
-  void MoveToNetworkThread();
+  void InitializeOnNetworkThread();
 
   // All public methods below this point must be called on the network thread
-  // after |MoveToNetworkThread| is called on the pref thread.
+  // after |InitializeOnNetworkThread| is called on the main thread.
 
   // Initializes the Monitor's URLRequestContextGetter.
   //
-  // Must be called on the network thread, after |MoveToNetworkThread|.
+  // Must be called on the network thread, after |InitializeOnNetworkThread|.
   void InitURLRequestContext(net::URLRequestContext* url_request_context);
 
   // Same, but for unittests where the Getter is readily available.
@@ -177,8 +177,8 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
 
   void MaybeHandleHeader(const RequestInfo& info);
 
-  bool OnPrefThread() const {
-    return pref_task_runner_->BelongsToCurrentThread();
+  bool OnMainThread() const {
+    return main_task_runner_->BelongsToCurrentThread();
   }
   bool OnNetworkThread() const {
     return network_task_runner_->BelongsToCurrentThread();
@@ -195,7 +195,7 @@ class DOMAIN_RELIABILITY_EXPORT DomainReliabilityMonitor
   std::unique_ptr<DomainReliabilityUploader> uploader_;
   DomainReliabilityContextManager context_manager_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   bool moved_to_network_thread_;

components/domain_reliability/monitor_unittest.cc

@@ -54,17 +54,17 @@ class DomainReliabilityMonitorTest : public testing::Test {
   typedef DomainReliabilityMonitor::RequestInfo RequestInfo;
 
   DomainReliabilityMonitorTest()
-      : pref_task_runner_(new base::TestSimpleTaskRunner()),
+      : main_task_runner(new base::TestSimpleTaskRunner()),
         network_task_runner_(new base::TestSimpleTaskRunner()),
         url_request_context_getter_(
             new net::TestURLRequestContextGetter(network_task_runner_)),
         time_(new MockTime()),
         monitor_("test-reporter",
                  DomainReliabilityContext::UploadAllowedCallback(),
-                 pref_task_runner_,
+                 main_task_runner,
                  network_task_runner_,
                  std::unique_ptr<MockableTime>(time_)) {
-    monitor_.MoveToNetworkThread();
+    monitor_.InitializeOnNetworkThread();
     monitor_.InitURLRequestContext(url_request_context_getter_);
     monitor_.SetDiscardUploads(false);
   }
@@ -104,7 +104,7 @@ class DomainReliabilityMonitorTest : public testing::Test {
     return monitor_.AddContextForTesting(std::move(config));
   }
 
-  scoped_refptr<base::TestSimpleTaskRunner> pref_task_runner_;
+  scoped_refptr<base::TestSimpleTaskRunner> main_task_runner;
   scoped_refptr<base::TestSimpleTaskRunner> network_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   MockTime* time_;

components/domain_reliability/service.cc

@@ -15,11 +15,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/domain_reliability/context.h"
 #include "components/domain_reliability/monitor.h"
-#include "content/public/browser/browser_context.h"
-#include "content/public/browser/permission_controller.h"
-#include "content/public/browser/permission_type.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "third_party/blink/public/platform/modules/permissions/permission_status.mojom.h"
 #include "url/gurl.h"
 
 namespace domain_reliability {
@@ -51,11 +47,8 @@ std::unique_ptr<base::Value> GetWebUIDataOnNetworkTaskRunner(
 class DomainReliabilityServiceImpl : public DomainReliabilityService {
  public:
   explicit DomainReliabilityServiceImpl(
-      const std::string& upload_reporter_string,
-      content::BrowserContext* browser_context)
-      : upload_reporter_string_(upload_reporter_string),
-        browser_context_(browser_context),
-        weak_factory_(this) {}
+      const std::string& upload_reporter_string)
+      : upload_reporter_string_(upload_reporter_string), weak_factory_(this) {}
 
   ~DomainReliabilityServiceImpl() override {}
 
@@ -63,18 +56,15 @@ class DomainReliabilityServiceImpl : public DomainReliabilityService {
 
   std::unique_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
-      override {
+      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+      const DomainReliabilityContext::UploadAllowedCallback&
+          upload_allowed_callback) override {
     DCHECK(!network_task_runner_);
 
     std::unique_ptr<DomainReliabilityMonitor> monitor(
-        new DomainReliabilityMonitor(
-            upload_reporter_string_,
-            base::Bind(
-                &DomainReliabilityServiceImpl::CheckUploadAllowedOnIOThread,
-                weak_factory_.GetWeakPtr(), base::RetainedRef(ui_task_runner),
-                base::RetainedRef(network_task_runner)),
-            ui_task_runner, network_task_runner));
+        new DomainReliabilityMonitor(upload_reporter_string_,
+                                     upload_allowed_callback, ui_task_runner,
+                                     network_task_runner));
 
     monitor_ = monitor->MakeWeakPtr();
     network_task_runner_ = network_task_runner;
@@ -133,36 +123,7 @@ class DomainReliabilityServiceImpl : public DomainReliabilityService {
   }
 
  private:
-  static void CheckUploadAllowedOnIOThread(
-      base::WeakPtr<DomainReliabilityServiceImpl> service,
-      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-      const GURL& origin,
-      base::OnceCallback<void(bool)> callback) {
-    ui_task_runner->PostTask(
-        FROM_HERE,
-        base::BindOnce(
-            &DomainReliabilityServiceImpl::CheckUploadAllowedOnUIThread,
-            service, base::RetainedRef(network_task_runner), origin,
-            std::move(callback)));
-  }
-
-  void CheckUploadAllowedOnUIThread(
-      base::SingleThreadTaskRunner* network_task_runner,
-      const GURL& origin,
-      base::OnceCallback<void(bool)> callback) {
-    content::PermissionController* permission_controller =
-        content::BrowserContext::GetPermissionController(browser_context_);
-    DCHECK(permission_controller);
-    bool allowed = permission_controller->GetPermissionStatus(
-                       content::PermissionType::BACKGROUND_SYNC, origin,
-                       origin) == blink::mojom::PermissionStatus::GRANTED;
-    network_task_runner->PostTask(FROM_HERE,
-                                  base::BindOnce(std::move(callback), allowed));
-  }
-
   std::string upload_reporter_string_;
-  content::BrowserContext* browser_context_;
   base::WeakPtr<DomainReliabilityMonitor> monitor_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   base::WeakPtrFactory<DomainReliabilityServiceImpl> weak_factory_;
@@ -170,10 +131,8 @@ class DomainReliabilityServiceImpl : public DomainReliabilityService {
 
 // static
 DomainReliabilityService* DomainReliabilityService::Create(
-    const std::string& upload_reporter_string,
-    content::BrowserContext* browser_context) {
-  return new DomainReliabilityServiceImpl(upload_reporter_string,
-                                          browser_context);
+    const std::string& upload_reporter_string) {
+  return new DomainReliabilityServiceImpl(upload_reporter_string);
 }
 
 DomainReliabilityService::~DomainReliabilityService() {}

components/domain_reliability/service.h

@@ -16,7 +16,6 @@
 #include "components/domain_reliability/config.h"
 #include "components/domain_reliability/context.h"
 #include "components/domain_reliability/domain_reliability_export.h"
-#include "components/keyed_service/core/keyed_service.h"
 
 class GURL;
 
@@ -24,10 +23,6 @@ namespace base {
 class Value;
 }  // namespace base
 
-namespace content {
-class BrowserContext;
-}  // namespace content
-
 namespace net {
 class URLRequestContextGetter;
 }  // namespace net
@@ -36,29 +31,30 @@ namespace domain_reliability {
 
 class DomainReliabilityMonitor;
 
-// DomainReliabilityService is a KeyedService that manages a Monitor that lives
-// on another thread (as provided by the URLRequestContextGetter's task runner)
-// and proxies (selected) method calls to it. Destruction of the Monitor (on
-// that thread) is the responsibility of the caller.
-class DOMAIN_RELIABILITY_EXPORT DomainReliabilityService
-    : public KeyedService {
+// DomainReliabilityService manages a Monitor that (could) live on another
+// thread (as provided by the URLRequestContextGetter's task runner) and
+// proxies (selected) method calls to it. Destruction of the Monitor (on that
+// thread) is the responsibility of the caller.
+class DOMAIN_RELIABILITY_EXPORT DomainReliabilityService {
  public:
   // Creates a DomainReliabilityService that will contain a Monitor with the
   // given upload reporter string.
   static DomainReliabilityService* Create(
-      const std::string& upload_reporter_string,
-      content::BrowserContext* browser_context);
+      const std::string& upload_reporter_string);
 
-  ~DomainReliabilityService() override;
+  virtual ~DomainReliabilityService();
 
   // Initializes the Service: given the task runner on which Monitor methods
   // should be called, creates the Monitor and returns it. Can be called at
   // most once, and must be called before any of the below methods can be
   // called. The caller is responsible for destroying the Monitor on the given
-  // task runner when it is no longer needed.
+  // task runner when it is no longer needed. |upload_allowed_callback| is
+  // called on the network thread before every upload to check if it's allowed.
   virtual std::unique_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner) = 0;
+      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+      const DomainReliabilityContext::UploadAllowedCallback&
+          upload_allowed_callback) = 0;
 
   // Clears browsing data on the associated Monitor. |Init()| must have been
   // called first.