DCHECK(browser_context) in most methods of ContentBrowserClient.

ContentBrowserClients assume that |browser_context| client is not null
(e.g. HeadlessContentBrowserClient::DoesSiteRequireDedicatedProcess and
ChromeContentBrowserClientExtensionsPart::DoesSiteRequireDedicatedProcess).
To avoid surprises, this CL adds DCHECK(browser_context) to most methods
of ContentBrowserClients, so that the assumption is documented and
verified during //content-layer tests.

Bug: 787576
Change-Id: I115ab53bb64cebe50b5993a39b3e153e3054b1b3
Reviewed-on: https://chromium-review.googlesource.com/c/1276559Reviewed-by: Charlie Reis <creis@chromium.org>
Reviewed-by: Alex Moshchuk <alexmos@chromium.org>
Commit-Queue: Łukasz Anforowicz <lukasza@chromium.org>
Cr-Commit-Position: refs/heads/master@{#599752}

content/browser/browsing_instance.cc

@@ -18,6 +18,7 @@ namespace content {
 BrowsingInstance::BrowsingInstance(BrowserContext* browser_context)
     : browser_context_(browser_context),
       active_contents_count_(0u) {
+  DCHECK(browser_context);
 }
 
 bool BrowsingInstance::HasSiteInstance(const GURL& url) {

content/browser/child_process_security_policy_impl.cc

@@ -19,6 +19,7 @@
 #include "build/build_config.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/isolated_origin_util.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ -1174,8 +1175,16 @@ void ChildProcessSecurityPolicyImpl::LockToOrigin(int child_id,
   // call GetOriginLock or CheckOriginLock from any thread).
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  // "gurl" can be currently empty in some cases, such as file://blah.
-  DCHECK_EQ(SiteInstanceImpl::DetermineProcessLockURL(nullptr, gurl), gurl);
+#if DCHECK_IS_ON()
+  // Sanity-check that the |gurl| argument can be used as a lock.
+  RenderProcessHost* rph = RenderProcessHostImpl::FromID(child_id);
+  if (rph) {  // |rph| can be null in unittests.
+    DCHECK_EQ(SiteInstanceImpl::DetermineProcessLockURL(
+                  rph->GetBrowserContext(), gurl),
+              gurl);
+  }
+#endif
+
   base::AutoLock lock(lock_);
   auto state = security_state_.find(child_id);
   DCHECK(state != security_state_.end());

content/browser/frame_host/navigation_entry_impl_unittest.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/frame_host/navigation_entry_impl.h"
 
+#include <utility>
+
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ -13,6 +15,8 @@
 #include "build/build_config.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/public/browser/ssl_status.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
@@ -54,7 +58,7 @@ class NavigationEntryTest : public testing::Test {
   void SetUp() override {
     entry1_.reset(new NavigationEntryImpl);
 
-    instance_ = SiteInstanceImpl::Create(nullptr);
+    instance_ = SiteInstanceImpl::Create(&browser_context_);
     entry2_.reset(new NavigationEntryImpl(
         instance_, GURL("test:url"),
         Referrer(GURL("from"), blink::kWebReferrerPolicyDefault),
@@ -69,6 +73,10 @@ class NavigationEntryTest : public testing::Test {
   std::unique_ptr<NavigationEntryImpl> entry2_;
   // SiteInstances are deleted when their NavigationEntries are gone.
   scoped_refptr<SiteInstanceImpl> instance_;
+
+ private:
+  TestBrowserThreadBundle thread_bundle_;
+  TestBrowserContext browser_context_;
 };
 
 // Test unique ID accessors

content/browser/service_worker/embedded_worker_instance.cc

@@ -261,6 +261,7 @@ void SetupOnUIThread(base::WeakPtr<ServiceWorkerProcessManager> process_manager,
 
   // TODO(crbug.com/862854): Support changes to RendererPreferences while the
   // worker is running.
+  DCHECK(process_manager->browser_context() || process_manager->IsShutdown());
   GetContentClient()->browser()->UpdateRendererPreferencesForWorker(
       process_manager->browser_context(), &params->renderer_preferences);
 

content/browser/service_worker/service_worker_process_manager.cc

@@ -29,6 +29,7 @@ ServiceWorkerProcessManager::ServiceWorkerProcessManager(
       new_process_id_for_test_(ChildProcessHost::kInvalidUniqueID),
       weak_this_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(browser_context);
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 

content/browser/site_instance_impl.cc

@@ -59,6 +59,7 @@ SiteInstanceImpl::~SiteInstanceImpl() {
 // static
 scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::Create(
     BrowserContext* browser_context) {
+  DCHECK(browser_context);
   return base::WrapRefCounted(
       new SiteInstanceImpl(new BrowsingInstance(browser_context)));
 }
@@ -67,6 +68,7 @@ scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::Create(
 scoped_refptr<SiteInstanceImpl> SiteInstanceImpl::CreateForURL(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
   // This will create a new SiteInstance and BrowsingInstance.
   scoped_refptr<BrowsingInstance> instance(
       new BrowsingInstance(browser_context));
@@ -314,6 +316,7 @@ BrowserContext* SiteInstanceImpl::GetBrowserContext() const {
 // static
 scoped_refptr<SiteInstance> SiteInstance::Create(
     BrowserContext* browser_context) {
+  DCHECK(browser_context);
   return SiteInstanceImpl::Create(browser_context);
 }
 
@@ -321,6 +324,7 @@ scoped_refptr<SiteInstance> SiteInstance::Create(
 scoped_refptr<SiteInstance> SiteInstance::CreateForURL(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
   return SiteInstanceImpl::CreateForURL(browser_context, url);
 }
 
@@ -341,6 +345,8 @@ bool SiteInstanceImpl::IsSameWebSite(BrowserContext* browser_context,
                                      const GURL& real_src_url,
                                      const GURL& real_dest_url,
                                      bool should_compare_effective_urls) {
+  DCHECK(browser_context);
+
   GURL src_url =
       should_compare_effective_urls
           ? SiteInstanceImpl::GetEffectiveURL(browser_context, real_src_url)
@@ -555,6 +561,8 @@ bool SiteInstanceImpl::HasEffectiveURL(BrowserContext* browser_context,
 bool SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
+
   // If --site-per-process is enabled, site isolation is enabled everywhere.
   if (SiteIsolationPolicy::UseDedicatedProcessesForAllSites())
     return true;
@@ -590,6 +598,8 @@ bool SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
 // static
 bool SiteInstanceImpl::ShouldLockToOrigin(BrowserContext* browser_context,
                                           GURL site_url) {
+  DCHECK(browser_context);
+
   // Don't lock to origin in --single-process mode, since this mode puts
   // cross-site pages into the same process.
   if (RenderProcessHost::run_renderer_in_process())

content/browser/site_instance_impl_unittest.cc

@@ -163,13 +163,15 @@ class SiteInstanceTest : public testing::Test {
 
 // Test to ensure no memory leaks for SiteInstance objects.
 TEST_F(SiteInstanceTest, SiteInstanceDestructor) {
+  TestBrowserContext context;
+
   // The existence of this object will cause WebContentsImpl to create our
   // test one instead of the real one.
   RenderViewHostTestEnabler rvh_test_enabler;
   const GURL url("test:foo");
 
   // Ensure that instances are deleted when their NavigationEntries are gone.
-  scoped_refptr<SiteInstanceImpl> instance = SiteInstanceImpl::Create(nullptr);
+  scoped_refptr<SiteInstanceImpl> instance = SiteInstanceImpl::Create(&context);
   EXPECT_EQ(0, browser_client()->GetAndClearSiteInstanceDeleteCount());
 
   NavigationEntryImpl* e1 = new NavigationEntryImpl(
@@ -242,7 +244,9 @@ TEST_F(SiteInstanceTest, GetProcess) {
 
 // Test to ensure SetSite and site() work properly.
 TEST_F(SiteInstanceTest, SetSite) {
-  scoped_refptr<SiteInstanceImpl> instance(SiteInstanceImpl::Create(nullptr));
+  TestBrowserContext context;
+
+  scoped_refptr<SiteInstanceImpl> instance(SiteInstanceImpl::Create(&context));
   EXPECT_FALSE(instance->HasSite());
   EXPECT_TRUE(instance->GetSiteURL().is_empty());
 
@@ -256,53 +260,55 @@ TEST_F(SiteInstanceTest, SetSite) {
 
 // Test to ensure GetSiteForURL properly returns sites for URLs.
 TEST_F(SiteInstanceTest, GetSiteForURL) {
+  TestBrowserContext context;
+
   // Pages are irrelevant.
   GURL test_url = GURL("http://www.google.com/index.html");
-  GURL site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  GURL site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://google.com"), site_url);
   EXPECT_EQ("http", site_url.scheme());
   EXPECT_EQ("google.com", site_url.host());
 
   // Ports are irrelevant.
   test_url = GURL("https://www.google.com:8080");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("https://google.com"), site_url);
 
   // Punycode is canonicalized.
   test_url = GURL("http://☃snowperson☃.net:333/");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://xn--snowperson-di0gka.net"), site_url);
 
   // Username and password are stripped out.
   test_url = GURL("ftp://username:password@ftp.chromium.org/files/README");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("ftp://chromium.org"), site_url);
 
   // Literal IP addresses of any flavor are okay.
   test_url = GURL("http://127.0.0.1/a.html");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://127.0.0.1"), site_url);
   EXPECT_EQ("127.0.0.1", site_url.host());
 
   test_url = GURL("http://2130706433/a.html");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://127.0.0.1"), site_url);
   EXPECT_EQ("127.0.0.1", site_url.host());
 
   test_url = GURL("http://[::1]:2/page.html");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://[::1]"), site_url);
   EXPECT_EQ("[::1]", site_url.host());
 
   // Hostnames without TLDs are okay.
   test_url = GURL("http://foo/a.html");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://foo"), site_url);
   EXPECT_EQ("foo", site_url.host());
 
   // File URLs should include the scheme.
   test_url = GURL("file:///C:/Downloads/");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("file:"), site_url);
   EXPECT_EQ("file", site_url.scheme());
   EXPECT_FALSE(site_url.has_host());
@@ -311,7 +317,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   // maps *all* file://... URLs into "file://" origin) such file URLs still need
   // to map into "file:" site URL.  See also https://crbug.com/776160.
   test_url = GURL("file://server/path");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("file:"), site_url);
   EXPECT_EQ("file", site_url.scheme());
   EXPECT_FALSE(site_url.has_host());
@@ -319,7 +325,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   // Data URLs should include the whole URL, except for the hash, when Site
   // Isolation is enabled.  Otherwise they just include the scheme.
   test_url = GURL("data:text/html,foo");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   if (AreAllSitesIsolatedForTesting())
     EXPECT_EQ(test_url, site_url);
   else
@@ -327,7 +333,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   EXPECT_EQ("data", site_url.scheme());
   EXPECT_FALSE(site_url.has_host());
   test_url = GURL("data:text/html,foo#bar");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_FALSE(site_url.has_ref());
   if (AreAllSitesIsolatedForTesting()) {
     EXPECT_NE(test_url, site_url);
@@ -338,7 +344,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
 
   // Javascript URLs should include the scheme.
   test_url = GURL("javascript:foo();");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("javascript:"), site_url);
   EXPECT_EQ("javascript", site_url.scheme());
   EXPECT_FALSE(site_url.has_host());
@@ -347,12 +353,12 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   test_url = GURL(
       "blob:gopher://www.ftp.chromium.org/"
       "4d4ff040-6d61-4446-86d3-13ca07ec9ab9");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("gopher://chromium.org"), site_url);
 
   // Blob URLs with file origin also extract the site from the origin.
   test_url = GURL("blob:file:///1029e5a4-2983-4b90-a585-ed217563acfeb");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("file:"), site_url);
   EXPECT_EQ("file", site_url.scheme());
   EXPECT_FALSE(site_url.has_host());
@@ -361,13 +367,13 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   // when Site Isolation is enabled, except for the hash.  Otherwise they just
   // include the scheme.
   test_url = GURL("blob:null/1029e5a4-2983-4b90-a585-ed217563acfeb");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   if (AreAllSitesIsolatedForTesting())
     EXPECT_EQ(test_url, site_url);
   else
     EXPECT_EQ(GURL("blob:"), site_url);
   test_url = GURL("blob:null/1029e5a4-2983-4b90-a585-ed217563acfeb#foo");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_FALSE(site_url.has_ref());
   if (AreAllSitesIsolatedForTesting()) {
     EXPECT_NE(test_url, site_url);
@@ -380,12 +386,12 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   test_url = GURL(
       "blob:http://www.example.appspot.com:44/"
       "4d4ff040-6d61-4446-86d3-13ca07ec9ab9");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://example.appspot.com"), site_url);
 
   // The site of filesystem URLs is determined by the inner URL.
   test_url = GURL("filesystem:http://www.google.com/foo/bar.html?foo#bar");
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(GURL("http://google.com"), site_url);
 
   // Guest URLs are special and need to have the path in the site as well,
@@ -393,7 +399,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
   std::string guest_url(kGuestScheme);
   guest_url.append("://abc123/path");
   test_url = GURL(guest_url);
-  site_url = SiteInstance::GetSiteForURL(nullptr, test_url);
+  site_url = SiteInstance::GetSiteForURL(&context, test_url);
   EXPECT_EQ(test_url, site_url);
 
   DrainMessageLoop();
@@ -401,6 +407,7 @@ TEST_F(SiteInstanceTest, GetSiteForURL) {
 
 // Test that process lock URLs are computed without using effective URLs.
 TEST_F(SiteInstanceTest, ProcessLockDoesNotUseEffectiveURL) {
+  TestBrowserContext context;
   GURL test_url("https://some.app.foo.com/");
   GURL nonapp_site_url("https://foo.com/");
   GURL app_url("https://app.com/");
@@ -415,10 +422,10 @@ TEST_F(SiteInstanceTest, ProcessLockDoesNotUseEffectiveURL) {
   GURL expected_app_site_url(app_url.spec() + "#" + nonapp_site_url.spec());
   {
     GURL site_url = SiteInstanceImpl::GetSiteForURL(
-        nullptr, test_url, false /* use_effective_urls */);
+        &context, test_url, false /* use_effective_urls */);
     EXPECT_EQ(nonapp_site_url, site_url);
 
-    site_url = SiteInstanceImpl::GetSiteForURL(nullptr, test_url,
+    site_url = SiteInstanceImpl::GetSiteForURL(&context, test_url,
                                                true /* use_effective_urls */);
     EXPECT_EQ(expected_app_site_url, site_url);
   }
@@ -461,6 +468,7 @@ TEST_F(SiteInstanceTest, ProcessLockDoesNotUseEffectiveURL) {
 // tested in RegistryControlledDomainTest.  This test focuses on URLs with
 // different schemes or ports.
 TEST_F(SiteInstanceTest, IsSameWebSite) {
+  TestBrowserContext context;
   GURL url_foo = GURL("http://foo/a.html");
   GURL url_foo2 = GURL("http://foo/b.html");
   GURL url_foo_https = GURL("https://foo/a.html");
@@ -469,31 +477,31 @@ TEST_F(SiteInstanceTest, IsSameWebSite) {
   GURL url_blank = GURL(url::kAboutBlankURL);
 
   // Same scheme and port -> same site.
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_foo, url_foo2));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_foo, url_foo2));
 
   // Different scheme -> different site.
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, url_foo, url_foo_https));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, url_foo, url_foo_https));
 
   // Different port -> same site.
   // (Changes to document.domain make renderer ignore the port.)
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_foo, url_foo_port));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_foo, url_foo_port));
 
   // JavaScript links should be considered same site for anything.
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_javascript, url_foo));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_javascript, url_foo));
   EXPECT_TRUE(
-      SiteInstance::IsSameWebSite(nullptr, url_javascript, url_foo_https));
+      SiteInstance::IsSameWebSite(&context, url_javascript, url_foo_https));
   EXPECT_TRUE(
-      SiteInstance::IsSameWebSite(nullptr, url_javascript, url_foo_port));
+      SiteInstance::IsSameWebSite(&context, url_javascript, url_foo_port));
 
   // Navigating to a blank page is considered the same site.
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_foo, url_blank));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_foo_https, url_blank));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, url_foo_port, url_blank));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_foo, url_blank));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_foo_https, url_blank));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, url_foo_port, url_blank));
 
   // Navigating from a blank site is not considered to be the same site.
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, url_blank, url_foo));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, url_blank, url_foo_https));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, url_blank, url_foo_port));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, url_blank, url_foo));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, url_blank, url_foo_https));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, url_blank, url_foo_port));
 
   DrainMessageLoop();
 }
@@ -501,26 +509,30 @@ TEST_F(SiteInstanceTest, IsSameWebSite) {
 // Test that two file URLs are considered same-site if they have the same path,
 // even if they have different fragments.
 TEST_F(SiteInstanceTest, IsSameWebSiteForFileURLs) {
+  TestBrowserContext context;
+
   // Two identical file URLs should be same-site.
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, GURL("file:///foo/bar.html"),
-                                          GURL("file:///foo/bar.html")));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(
+      &context, GURL("file:///foo/bar.html"), GURL("file:///foo/bar.html")));
 
   // File URLs with the same path but different fragment are considered
   // same-site.
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, GURL("file:///foo/bar.html"),
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context,
+                                          GURL("file:///foo/bar.html"),
                                           GURL("file:///foo/bar.html#baz")));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(
-      nullptr, GURL("file:///foo/bar.html#baz"), GURL("file:///foo/bar.html")));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context,
+                                          GURL("file:///foo/bar.html#baz"),
+                                          GURL("file:///foo/bar.html")));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context,
                                           GURL("file:///foo/bar.html#baz"),
                                           GURL("file:///foo/bar.html#qux")));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, GURL("file:///#abc"),
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, GURL("file:///#abc"),
                                           GURL("file:///#def")));
 
   // Other cases are cross-site.
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, GURL("file:///foo.html"),
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, GURL("file:///foo.html"),
                                            GURL("file:///foo/bar.html")));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, GURL("file:///#bar"),
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, GURL("file:///#bar"),
                                            GURL("file:///foo/#bar")));
 }
 
@@ -833,6 +845,7 @@ TEST_F(SiteInstanceTest, NoProcessPerSiteForEmptySite) {
 // Check that an URL is considered same-site with blob: and filesystem: URLs
 // with a matching inner origin.  See https://crbug.com/726370.
 TEST_F(SiteInstanceTest, IsSameWebsiteForNestedURLs) {
+  TestBrowserContext context;
   GURL foo_url("http://foo.com/");
   GURL bar_url("http://bar.com/");
   GURL blob_foo_url("blob:http://foo.com/uuid");
@@ -840,36 +853,38 @@ TEST_F(SiteInstanceTest, IsSameWebsiteForNestedURLs) {
   GURL fs_foo_url("filesystem:http://foo.com/path/");
   GURL fs_bar_url("filesystem:http://bar.com/path/");
 
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, foo_url, blob_foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, blob_foo_url, foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, foo_url, blob_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, blob_foo_url, bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, foo_url, blob_foo_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, blob_foo_url, foo_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, foo_url, blob_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, blob_foo_url, bar_url));
 
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, foo_url, fs_foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, fs_foo_url, foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, foo_url, fs_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, fs_foo_url, bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, foo_url, fs_foo_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, fs_foo_url, foo_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, foo_url, fs_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, fs_foo_url, bar_url));
 
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, blob_foo_url, fs_foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, blob_foo_url, fs_bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, blob_foo_url, fs_foo_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, blob_foo_url, fs_bar_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, blob_foo_url, blob_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, fs_foo_url, fs_bar_url));
+      SiteInstance::IsSameWebSite(&context, blob_foo_url, blob_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, fs_foo_url, fs_bar_url));
 
   // Verify that the scheme and ETLD+1 are used for comparison.
   GURL www_bar_url("http://www.bar.com/");
   GURL bar_org_url("http://bar.org/");
   GURL https_bar_url("https://bar.com/");
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, www_bar_url, bar_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, www_bar_url, blob_bar_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, www_bar_url, fs_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, bar_org_url, bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, bar_org_url, blob_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, bar_org_url, fs_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, https_bar_url, bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, www_bar_url, bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, www_bar_url, blob_bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, www_bar_url, fs_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, bar_org_url, bar_url));
+  EXPECT_FALSE(
+      SiteInstance::IsSameWebSite(&context, bar_org_url, blob_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, bar_org_url, fs_bar_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, https_bar_url, bar_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, https_bar_url, blob_bar_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, https_bar_url, fs_bar_url));
+      SiteInstance::IsSameWebSite(&context, https_bar_url, blob_bar_url));
+  EXPECT_FALSE(
+      SiteInstance::IsSameWebSite(&context, https_bar_url, fs_bar_url));
 }
 
 TEST_F(SiteInstanceTest, IsolatedOrigins) {
@@ -878,9 +893,10 @@ TEST_F(SiteInstanceTest, IsolatedOrigins) {
   GURL isolated_bar_url("http://isolated.bar.com");
 
   auto* policy = ChildProcessSecurityPolicyImpl::GetInstance();
+  TestBrowserContext context;
 
   EXPECT_FALSE(policy->IsIsolatedOrigin(url::Origin::Create(isolated_foo_url)));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, foo_url, isolated_foo_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, foo_url, isolated_foo_url));
 
   policy->AddIsolatedOrigins({url::Origin::Create(isolated_foo_url)});
   EXPECT_TRUE(policy->IsIsolatedOrigin(url::Origin::Create(isolated_foo_url)));
@@ -899,42 +915,44 @@ TEST_F(SiteInstanceTest, IsolatedOrigins) {
 
   // IsSameWebSite should compare origins rather than sites if either URL is an
   // isolated origin.
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, foo_url, isolated_foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, isolated_foo_url, foo_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, isolated_foo_url, isolated_bar_url));
-  EXPECT_TRUE(
-      SiteInstance::IsSameWebSite(nullptr, isolated_foo_url, isolated_foo_url));
+      SiteInstance::IsSameWebSite(&context, foo_url, isolated_foo_url));
+  EXPECT_FALSE(
+      SiteInstance::IsSameWebSite(&context, isolated_foo_url, foo_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, isolated_foo_url,
+                                           isolated_bar_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, isolated_foo_url,
+                                          isolated_foo_url));
 
   // Ensure blob and filesystem URLs with isolated origins are compared
   // correctly.
   GURL isolated_blob_foo_url("blob:http://isolated.foo.com/uuid");
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, isolated_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, isolated_foo_url,
                                           isolated_blob_foo_url));
   GURL isolated_filesystem_foo_url("filesystem:http://isolated.foo.com/bar/");
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, isolated_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, isolated_foo_url,
                                           isolated_filesystem_foo_url));
 
   // The site URL for an isolated origin should be the full origin rather than
   // eTLD+1.
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, isolated_foo_url));
+            SiteInstance::GetSiteForURL(&context, isolated_foo_url));
   EXPECT_EQ(isolated_bar_url,
-            SiteInstance::GetSiteForURL(nullptr, isolated_bar_url));
+            SiteInstance::GetSiteForURL(&context, isolated_bar_url));
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, isolated_blob_foo_url));
+            SiteInstance::GetSiteForURL(&context, isolated_blob_foo_url));
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, isolated_filesystem_foo_url));
+            SiteInstance::GetSiteForURL(&context, isolated_filesystem_foo_url));
 
   // Isolated origins always require a dedicated process.
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, isolated_foo_url));
+      &context, isolated_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, isolated_bar_url));
+      &context, isolated_bar_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, isolated_blob_foo_url));
+      &context, isolated_blob_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, isolated_filesystem_foo_url));
+      &context, isolated_filesystem_foo_url));
 
   // Cleanup.
   policy->RemoveIsolatedOriginForTesting(url::Origin::Create(isolated_foo_url));
@@ -983,6 +1001,7 @@ TEST_F(SiteInstanceTest, SubdomainOnIsolatedSite) {
   GURL isolated_url("http://isolated.com");
   GURL foo_isolated_url("http://foo.isolated.com");
 
+  TestBrowserContext context;
   auto* policy = ChildProcessSecurityPolicyImpl::GetInstance();
   policy->AddIsolatedOrigins({url::Origin::Create(isolated_url)});
 
@@ -1006,15 +1025,15 @@ TEST_F(SiteInstanceTest, SubdomainOnIsolatedSite) {
   // should use the isolated origin's host and not its own host as the site
   // URL.
   EXPECT_EQ(isolated_url,
-            SiteInstance::GetSiteForURL(nullptr, foo_isolated_url));
+            SiteInstance::GetSiteForURL(&context, foo_isolated_url));
 
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, foo_isolated_url));
+      &context, foo_isolated_url));
 
   EXPECT_TRUE(
-      SiteInstance::IsSameWebSite(nullptr, isolated_url, foo_isolated_url));
+      SiteInstance::IsSameWebSite(&context, isolated_url, foo_isolated_url));
   EXPECT_TRUE(
-      SiteInstance::IsSameWebSite(nullptr, foo_isolated_url, isolated_url));
+      SiteInstance::IsSameWebSite(&context, foo_isolated_url, isolated_url));
 
   // Don't try to match subdomains on IP addresses.
   GURL isolated_ip("http://127.0.0.1");
@@ -1033,6 +1052,7 @@ TEST_F(SiteInstanceTest, SubdomainOnIsolatedOrigin) {
   GURL bar_isolated_foo_url("http://bar.isolated.foo.com");
   GURL baz_isolated_foo_url("http://baz.isolated.foo.com");
 
+  TestBrowserContext context;
   auto* policy = ChildProcessSecurityPolicyImpl::GetInstance();
   policy->AddIsolatedOrigins({url::Origin::Create(isolated_foo_url)});
 
@@ -1043,38 +1063,40 @@ TEST_F(SiteInstanceTest, SubdomainOnIsolatedOrigin) {
   EXPECT_TRUE(
       policy->IsIsolatedOrigin(url::Origin::Create(baz_isolated_foo_url)));
 
-  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(nullptr, foo_url));
+  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(&context, foo_url));
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, isolated_foo_url));
+            SiteInstance::GetSiteForURL(&context, isolated_foo_url));
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, bar_isolated_foo_url));
+            SiteInstance::GetSiteForURL(&context, bar_isolated_foo_url));
   EXPECT_EQ(isolated_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, baz_isolated_foo_url));
+            SiteInstance::GetSiteForURL(&context, baz_isolated_foo_url));
 
   if (!AreAllSitesIsolatedForTesting()) {
     EXPECT_FALSE(
-        SiteInstanceImpl::DoesSiteRequireDedicatedProcess(nullptr, foo_url));
+        SiteInstanceImpl::DoesSiteRequireDedicatedProcess(&context, foo_url));
   }
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, isolated_foo_url));
+      &context, isolated_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, bar_isolated_foo_url));
+      &context, bar_isolated_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, baz_isolated_foo_url));
+      &context, baz_isolated_foo_url));
 
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, foo_url, isolated_foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, isolated_foo_url, foo_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, foo_url, bar_isolated_foo_url));
+      SiteInstance::IsSameWebSite(&context, foo_url, isolated_foo_url));
+  EXPECT_FALSE(
+      SiteInstance::IsSameWebSite(&context, isolated_foo_url, foo_url));
+  EXPECT_FALSE(
+      SiteInstance::IsSameWebSite(&context, foo_url, bar_isolated_foo_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, bar_isolated_foo_url, foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, bar_isolated_foo_url,
+      SiteInstance::IsSameWebSite(&context, bar_isolated_foo_url, foo_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, bar_isolated_foo_url,
                                           isolated_foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, isolated_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, isolated_foo_url,
                                           bar_isolated_foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, bar_isolated_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, bar_isolated_foo_url,
                                           baz_isolated_foo_url));
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, baz_isolated_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, baz_isolated_foo_url,
                                           bar_isolated_foo_url));
 
   // Cleanup.
@@ -1087,6 +1109,7 @@ TEST_F(SiteInstanceTest, MultipleIsolatedOriginsWithCommonSite) {
   GURL baz_bar_foo_url("http://baz.bar.foo.com");
   GURL qux_baz_bar_foo_url("http://qux.baz.bar.foo.com");
 
+  TestBrowserContext context;
   auto* policy = ChildProcessSecurityPolicyImpl::GetInstance();
   policy->AddIsolatedOrigins(
       {url::Origin::Create(foo_url), url::Origin::Create(baz_bar_foo_url)});
@@ -1097,33 +1120,33 @@ TEST_F(SiteInstanceTest, MultipleIsolatedOriginsWithCommonSite) {
   EXPECT_TRUE(
       policy->IsIsolatedOrigin(url::Origin::Create(qux_baz_bar_foo_url)));
 
-  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(nullptr, foo_url));
-  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(nullptr, bar_foo_url));
+  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(&context, foo_url));
+  EXPECT_EQ(foo_url, SiteInstance::GetSiteForURL(&context, bar_foo_url));
   EXPECT_EQ(baz_bar_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, baz_bar_foo_url));
+            SiteInstance::GetSiteForURL(&context, baz_bar_foo_url));
   EXPECT_EQ(baz_bar_foo_url,
-            SiteInstance::GetSiteForURL(nullptr, qux_baz_bar_foo_url));
+            SiteInstance::GetSiteForURL(&context, qux_baz_bar_foo_url));
 
   EXPECT_TRUE(
-      SiteInstanceImpl::DoesSiteRequireDedicatedProcess(nullptr, foo_url));
+      SiteInstanceImpl::DoesSiteRequireDedicatedProcess(&context, foo_url));
   EXPECT_TRUE(
-      SiteInstanceImpl::DoesSiteRequireDedicatedProcess(nullptr, bar_foo_url));
+      SiteInstanceImpl::DoesSiteRequireDedicatedProcess(&context, bar_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, baz_bar_foo_url));
+      &context, baz_bar_foo_url));
   EXPECT_TRUE(SiteInstanceImpl::DoesSiteRequireDedicatedProcess(
-      nullptr, qux_baz_bar_foo_url));
+      &context, qux_baz_bar_foo_url));
 
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, foo_url, bar_foo_url));
-  EXPECT_FALSE(SiteInstance::IsSameWebSite(nullptr, foo_url, baz_bar_foo_url));
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, foo_url, bar_foo_url));
+  EXPECT_FALSE(SiteInstance::IsSameWebSite(&context, foo_url, baz_bar_foo_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, foo_url, qux_baz_bar_foo_url));
+      SiteInstance::IsSameWebSite(&context, foo_url, qux_baz_bar_foo_url));
 
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, bar_foo_url, baz_bar_foo_url));
+      SiteInstance::IsSameWebSite(&context, bar_foo_url, baz_bar_foo_url));
   EXPECT_FALSE(
-      SiteInstance::IsSameWebSite(nullptr, bar_foo_url, qux_baz_bar_foo_url));
+      SiteInstance::IsSameWebSite(&context, bar_foo_url, qux_baz_bar_foo_url));
 
-  EXPECT_TRUE(SiteInstance::IsSameWebSite(nullptr, baz_bar_foo_url,
+  EXPECT_TRUE(SiteInstance::IsSameWebSite(&context, baz_bar_foo_url,
                                           qux_baz_bar_foo_url));
 
   // Cleanup.

content/public/browser/content_browser_client.cc

@@ -78,6 +78,7 @@ bool ContentBrowserClient::AllowGpuLaunchRetryOnIOThread() {
 
 GURL ContentBrowserClient::GetEffectiveURL(BrowserContext* browser_context,
                                            const GURL& url) {
+  DCHECK(browser_context);
   return url;
 }
 
@@ -87,6 +88,7 @@ bool ContentBrowserClient::ShouldCompareEffectiveURLsForSiteInstanceSelection(
     bool is_main_frame,
     const GURL& candidate_url,
     const GURL& destination_url) {
+  DCHECK(browser_context);
   return true;
 }
 
@@ -96,6 +98,7 @@ bool ContentBrowserClient::ShouldUseMobileFlingCurve() const {
 
 bool ContentBrowserClient::ShouldUseProcessPerSite(
     BrowserContext* browser_context, const GURL& effective_url) {
+  DCHECK(browser_context);
   return false;
 }
 
@@ -108,11 +111,13 @@ bool ContentBrowserClient::ShouldUseSpareRenderProcessHost(
 bool ContentBrowserClient::DoesSiteRequireDedicatedProcess(
     BrowserContext* browser_context,
     const GURL& effective_site_url) {
+  DCHECK(browser_context);
   return false;
 }
 
 bool ContentBrowserClient::ShouldLockToOrigin(BrowserContext* browser_context,
                                               const GURL& effective_url) {
+  DCHECK(browser_context);
   return true;
 }
 
@@ -165,6 +170,7 @@ bool ContentBrowserClient::ShouldAllowOpenURL(SiteInstance* site_instance,
 bool ContentBrowserClient::IsURLAcceptableForWebUI(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
   return false;
 }
 
@@ -185,6 +191,7 @@ bool ContentBrowserClient::MayReuseHost(RenderProcessHost* process_host) {
 
 bool ContentBrowserClient::ShouldTryToUseExistingProcessHost(
       BrowserContext* browser_context, const GURL& url) {
+  DCHECK(browser_context);
   return false;
 }
 
@@ -247,6 +254,7 @@ std::string ContentBrowserClient::GetApplicationLocale() {
 }
 
 std::string ContentBrowserClient::GetAcceptLangs(BrowserContext* context) {
+  DCHECK(context);
   return std::string();
 }
 
@@ -282,16 +290,20 @@ bool ContentBrowserClient::AllowSharedWorker(
     BrowserContext* context,
     int render_process_id,
     int render_frame_id) {
+  DCHECK(context);
   return true;
 }
 
 bool ContentBrowserClient::IsDataSaverEnabled(BrowserContext* context) {
+  DCHECK(context);
   return false;
 }
 
 void ContentBrowserClient::UpdateRendererPreferencesForWorker(
     BrowserContext* browser_context,
-    RendererPreferences* out_prefs) {}
+    RendererPreferences* out_prefs) {
+  // |browser_context| may be null (e.g. during shutdown of a service worker).
+}
 
 bool ContentBrowserClient::AllowGetCookie(const GURL& url,
                                           const GURL& first_party,
@@ -346,6 +358,7 @@ ContentBrowserClient::AllowWebBluetooth(
     content::BrowserContext* browser_context,
     const url::Origin& requesting_origin,
     const url::Origin& embedding_origin) {
+  DCHECK(browser_context);
   return AllowWebBluetoothResult::ALLOW;
 }
 
@@ -361,6 +374,8 @@ void ContentBrowserClient::GetQuotaSettings(
     BrowserContext* context,
     StoragePartition* partition,
     storage::OptionalQuotaSettingsCallback callback) {
+  DCHECK(context);
+
   // By default, no quota is provided, embedders should override.
   std::move(callback).Run(storage::GetNoQuotaSettings());
 }
@@ -412,12 +427,15 @@ bool ContentBrowserClient::ShouldUseGmsCoreGeolocationProvider() {
 std::string ContentBrowserClient::GetStoragePartitionIdForSite(
     BrowserContext* browser_context,
     const GURL& site) {
+  DCHECK(browser_context);
   return std::string();
 }
 
 bool ContentBrowserClient::IsValidStoragePartitionId(
     BrowserContext* browser_context,
     const std::string& partition_id) {
+  DCHECK(browser_context);
+
   // Since the GetStoragePartitionIdForChildProcess() only generates empty
   // strings, we should only ever see empty strings coming back.
   return partition_id.empty();
@@ -430,6 +448,8 @@ void ContentBrowserClient::GetStoragePartitionConfigForSite(
     std::string* partition_domain,
     std::string* partition_name,
     bool* in_memory) {
+  DCHECK(browser_context);
+
   partition_domain->clear();
   partition_name->clear();
   *in_memory = false;
@@ -497,17 +517,20 @@ bool ContentBrowserClient::AllowPepperSocketAPI(
     const GURL& url,
     bool private_api,
     const SocketPermissionRequest* params) {
+  DCHECK(browser_context);
   return false;
 }
 
 bool ContentBrowserClient::IsPepperVpnProviderAPIAllowed(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
   return false;
 }
 
 std::unique_ptr<VpnServiceProxy> ContentBrowserClient::GetVpnServiceProxy(
     BrowserContext* browser_context) {
+  DCHECK(browser_context);
   return nullptr;
 }
 
@@ -527,17 +550,22 @@ TracingDelegate* ContentBrowserClient::GetTracingDelegate() {
 bool ContentBrowserClient::IsPluginAllowedToCallRequestOSFileHandle(
     BrowserContext* browser_context,
     const GURL& url) {
+  DCHECK(browser_context);
   return false;
 }
 
 bool ContentBrowserClient::IsPluginAllowedToUseDevChannelAPIs(
     BrowserContext* browser_context,
     const GURL& url) {
+  // |browser_context| may be null (e.g. when called from
+  // PpapiPluginProcessHost::PpapiPluginProcessHost).
+
   return false;
 }
 
 std::string ContentBrowserClient::GetServiceUserIdForBrowserContext(
     BrowserContext* browser_context) {
+  DCHECK(browser_context);
   return base::GenerateGUID();
 }
 
@@ -564,6 +592,7 @@ void ContentBrowserClient::OpenURL(
     content::BrowserContext* browser_context,
     const content::OpenURLParams& params,
     const base::Callback<void(content::WebContents*)>& callback) {
+  DCHECK(browser_context);
   callback.Run(nullptr);
 }
 
@@ -676,6 +705,7 @@ bool ContentBrowserClient::WillCreateURLLoaderFactory(
     const url::Origin& request_initiator,
     network::mojom::URLLoaderFactoryRequest* factory_request,
     bool* bypass_redirect_checks) {
+  DCHECK(browser_context);
   return false;
 }
 
@@ -698,6 +728,7 @@ network::mojom::NetworkContextPtr ContentBrowserClient::CreateNetworkContext(
     BrowserContext* context,
     bool in_memory,
     const base::FilePath& relative_partition_path) {
+  DCHECK(context);
   if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
     return nullptr;
 
@@ -746,6 +777,7 @@ bool ContentBrowserClient::ShowPaymentHandlerWindow(
     content::BrowserContext* browser_context,
     const GURL& url,
     base::OnceCallback<void(bool, int, int)> callback) {
+  DCHECK(browser_context);
   return false;
 }
 
@@ -806,7 +838,9 @@ bool ContentBrowserClient::IsSafeRedirectTarget(const GURL& url,
 
 void ContentBrowserClient::RegisterRendererPreferenceWatcherForWorkers(
     BrowserContext* browser_context,
-    mojom::RendererPreferenceWatcherPtr watcher) {}
+    mojom::RendererPreferenceWatcherPtr watcher) {
+  // |browser_context| may be null (e.g. during shutdown of a service worker).
+}
 
 base::Optional<std::string> ContentBrowserClient::GetOriginPolicyErrorPage(
     OriginPolicyErrorReason error_reason,