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::InitializeResourceContext(
+    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;
+  // Can be null in tests.
+  if (request_context_getter_)
+    request_context_getter_->AddObserver(this);
+}
+
+void ServiceWorkerContextWrapper::OnContextShuttingDown() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  request_context_getter_->RemoveObserver(this);

[michaeln, 2016/03/10 21:15:53]

You mentioned this isn't called on ContentShell.

I think it might be good to RemoveObserver() in ShutdownOnIO() and to assert
that resource_context_ is null in the dtor? So we don't depend on
ResourcedContextShutdown happening prior to ServiceWorkerContextWrapper
destruction.

[mmenke, 2016/03/10 21:20:51]

I view this as a hack to resolve incorrect class dependencies.  I'm reluctant to
encourage increasing the amount of code that relies on it.

+
+  // 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
+  // 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