Add a ServiceWorkerContextObserver to content's public API.

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>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
-#include "content/browser/service_worker/service_worker_context_core.h"
-#include "content/browser/service_worker/service_worker_context_core_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/service_worker_context_observer.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
 
 namespace {
 
 typedef std::set<std::string> HeaderNameSet;
 base::LazyInstance<HeaderNameSet>::DestructorAtExit g_excluded_header_name_set =
@@ skipping 52 matching lines @@
                                           header_names.end());
 }
 
 bool ServiceWorkerContext::IsExcludedHeaderNameForFetchEvent(
     const std::string& header_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return g_excluded_header_name_set.Get().find(header_name) !=
          g_excluded_header_name_set.Get().end();
 }
 
+bool ServiceWorkerContext::ScopeMatches(const GURL& scope, const GURL& url) {
+  return ServiceWorkerUtils::ScopeMatches(scope, url);
+}
+
+void ServiceWorkerContextWrapper::OnRegistrationStored(int64_t registration_id,
+                                                       const GURL& pattern) {
+  for (auto& observer : observer_list_)
+    observer.OnRegistrationStored(pattern);
+}
+
+void ServiceWorkerContextWrapper::AddObserver(
+    ServiceWorkerContextObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void ServiceWorkerContextWrapper::RemoveObserver(
+    ServiceWorkerContextObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 ServiceWorkerContextWrapper::ServiceWorkerContextWrapper(
     BrowserContext* browser_context)
     : core_observer_list_(
           new base::ObserverListThreadSafe<ServiceWorkerContextCoreObserver>()),
       process_manager_(new ServiceWorkerProcessManager(browser_context)),
       is_incognito_(false),
       storage_partition_(nullptr),
       resource_context_(nullptr) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  // Add this object as an observer of the wrapped |context_core_|. This lets us
+  // forward observer methods to observers outside of content.
+  core_observer_list_->AddObserver(this);
 }
 
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
+  core_observer_list_->RemoveObserver(this);

[kinuko, 2017/06/14 07:33:45]

I think this wrapper almost always live longer than core... while this is
probably fine as well.  (Can you comment about that not to confuse readers?)

[dominickn, 2017/06/14 09:10:58]

You can see in #ps1 that a bunch of test failures occurred when I didn't have
this RemoveObserver call. There were a bunch of use-after-frees on the Wrapper
object, I think stemming from the EmbeddedWorkerTestHelper and how it
creates/destroys a Wrapper and a ContextCore. I added a clarifying comment for
this.

   DCHECK(!resource_context_);
 }
 
 void ServiceWorkerContextWrapper::Init(
     const base::FilePath& user_data_directory,
     storage::QuotaManagerProxy* quota_manager_proxy,
     storage::SpecialStoragePolicy* special_storage_policy) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   is_incognito_ = user_data_directory.empty();
@@ skipping 707 matching lines @@
                                     service_worker_provider_id,
                                     std::move(client_ptr_info));
 }
 
 ServiceWorkerContextCore* ServiceWorkerContextWrapper::context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return context_core_.get();
 }
 
 }  // namespace content