Introduces DevToolsManagerDelegate.

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 "base/files/file_path.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 
 namespace content {
 
 ServiceWorkerContextWrapper::ServiceWorkerContextWrapper(
     BrowserContext* browser_context)
     : observer_list_(
           new ObserverListThreadSafe<ServiceWorkerContextObserver>()),
       browser_context_(browser_context) {
+  observer_list_->AddObserver(this);

[michaeln, 2014/05/01 02:52:07]

this should always be called on the UI thread, we're depending on that now
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[horo, 2014/05/01 04:52:32]

Done.
Moved to Init().

 }
 
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
+  observer_list_->RemoveObserver(this);

[michaeln, 2014/05/01 02:52:07]

does ObserverListThreadSafe require that an observer be removed on the same
thread on which it was added? bah... it does.

  // Remove an observer from the list if it is in the list.
  // If there are pending notifications in-transit to the observer, they will
  // be aborted.
  // If the observer to be removed is in the list, RemoveObserver MUST
  // be called from the same thread which called AddObserver.
  void RemoveObserver(ObserverType* obs)

There's nothing really guaranteeing that the dtor happens on the UI thread right
now (that i can see). Maybe the AddObserver and RemoveObserver calls could be
moved to Init() and Shutdown() respectively. Those are guaranteed to be called
on the UI thread.

[horo, 2014/05/01 04:52:32]

Done.
Moved to Shutdown().

 }
 
 void ServiceWorkerContextWrapper::Init(
     const base::FilePath& user_data_directory,
     quota::QuotaManagerProxy* quota_manager_proxy) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&ServiceWorkerContextWrapper::Init,
@@ skipping 89 matching lines @@
     return;
   }
 
   context()->UnregisterServiceWorker(
       pattern,
       source_process_id,
       NULL /* provider_host */,
       base::Bind(&FinishUnregistrationOnIO, continuation));
 }
 
+void ServiceWorkerContextWrapper::AddStatusChangeCallback(
+    const base::Callback<void(void)>& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return status_change_callbacks_.push_back(callback);
+}
+
+void ServiceWorkerContextWrapper::RemoveStatusChangeCallback(
+    const base::Callback<void(void)>& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  for (std::vector<base::Callback<void(void)> >::iterator it =
+           status_change_callbacks_.begin();
+       it != status_change_callbacks_.end();) {
+    if (it->Equals(callback)) {
+      it = status_change_callbacks_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 void ServiceWorkerContextWrapper::AddObserver(
     ServiceWorkerContextObserver* observer) {
   observer_list_->AddObserver(observer);
 }
 
 void ServiceWorkerContextWrapper::RemoveObserver(
     ServiceWorkerContextObserver* observer) {
   observer_list_->RemoveObserver(observer);
 }
 
+void ServiceWorkerContextWrapper::GetRunningServiceWorkerInfo(
+    const GetRunningServiceWorkerInfoCallback& callback) {
+  // TODO(horo): Implement this.
+  NOTIMPLEMENTED();
+}
+
+void ServiceWorkerContextWrapper::OnWorkerStarted(int64 version_id,
+                                                  int process_id,
+                                                  int thread_id) {
+  CallStatusChangeCallback();
+}
+
+void ServiceWorkerContextWrapper::OnWorkerStopped(int64 version_id,
+                                                  int process_id,
+                                                  int thread_id) {
+  CallStatusChangeCallback();
+}
+
+void ServiceWorkerContextWrapper::OnVersionStateChanged(int64 version_id) {
+  CallStatusChangeCallback();
+}
+
+void ServiceWorkerContextWrapper::CallStatusChangeCallback() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  for (size_t i = 0; i < status_change_callbacks_.size(); ++i) {
+    status_change_callbacks_[i].Run();
+  }
+}
+
 }  // namespace content