service worker: Observe when resource context is shutting down

content/browser/service_worker/service_worker_context_wrapper.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 112 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   storage_partition_ = nullptr;
   process_manager_->Shutdown();
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ServiceWorkerContextWrapper::ShutdownOnIO, this));
 }
 
+void ServiceWorkerContextWrapper::InitializeOnIO(

[michaeln, 2016/03/08 22:04:27]

naming nit driveby: since there already are Init() and InitInternal() methods on
this object (with the latter intended to be run on the IO thread), maybe call
this one InitializeResourceContext

[falken, 2016/03/10 01:25:35]

Done.

+    ResourceContext* resource_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  resource_context_ = resource_context;
+  request_context_getter_ = request_context_getter;
+  request_context_getter_->AddObserver(this);
+}
+
+void ServiceWorkerContextWrapper::OnContextShuttingDown() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);

[falken, 2016/03/08 09:59:11]

mmenke: URLRequestContextGetterObserver documentation says "network thread" but
it seems to be called on the IO thread via
ChromeURLRequestContextGetter::NotifyContextShuttingDown. Is this DCHECK safe?

[michaeln, 2016/03/08 22:04:27]

yes, content::iothread == net::networkthread

[mmenke, 2016/03/09 18:33:42]

Correct.  net/ is below content/, so doesn't know what thread it will be used on
(It should also be possible to create multiple URLRequestContexts that live on
different threads, though there are currently some globals that make doing so a
bit iffy)

+  request_context_getter_->RemoveObserver(this);
+
+  // OnContextShuttingDown is called when the ProfileIOData (ResourceContext) is
+  // shutting down, so call ShutdownOnIO() to clear resource_context_.
+  // This doesn't seem to be called when using content_shell, so we still must

[mmenke, 2016/03/09 18:33:42]

This bug may still exist with content shell, or other embedders, depending on
their URLRequestContext ownership model (If the getter owns the context, they're
safe.  Otherwise, they will probably still have this problem)

It's up to the class that owns the URLRequestContext to tell the
URLRequestContextGetter when it goes away, but currently, only ProfileIOData
does that, I believe.

+  // also call ShutdownOnIO() in Shutdown(), which is called when the storage
+  // partition is destroyed.
+  ShutdownOnIO();
+}
+
 void ServiceWorkerContextWrapper::DeleteAndStartOver() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!context_core_) {
     // The context could be null due to system shutdown or restart failure. In
     // either case, we should not have to recover the system, so just return
     // here.
     return;
   }
   context_core_->DeleteAndStartOver(
       base::Bind(&ServiceWorkerContextWrapper::DidDeleteAndStartOver, this));
 }
 
 StoragePartitionImpl* ServiceWorkerContextWrapper::storage_partition() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return storage_partition_;
 }
 
 void ServiceWorkerContextWrapper::set_storage_partition(
     StoragePartitionImpl* storage_partition) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   storage_partition_ = storage_partition;
 }
 
 ResourceContext* ServiceWorkerContextWrapper::resource_context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return resource_context_;
 }
 
-void ServiceWorkerContextWrapper::set_resource_context(
-    ResourceContext* resource_context) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  resource_context_ = resource_context;
-}
-
 static void FinishRegistrationOnIO(
     const ServiceWorkerContext::ResultCallback& continuation,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     int64_t registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(continuation, status == SERVICE_WORKER_OK));
@@ skipping 521 matching lines @@
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnStorageWiped);
 }
 
 ServiceWorkerContextCore* ServiceWorkerContextWrapper::context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return context_core_.get();
 }
 
 }  // namespace content