Track webcore worker message loops in chromium.

webkit/glue/worker_task_runner.cc

Index: webkit/glue/worker_task_runner.cc
diff --git a/webkit/glue/worker_task_runner.cc b/webkit/glue/worker_task_runner.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e55d1a37e7f2356d339c41881d1ca6d1f7e21def
--- /dev/null
+++ b/webkit/glue/worker_task_runner.cc
@@ -0,0 +1,103 @@
+// Copyright (c) 2011 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 "base/callback.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "webkit/glue/worker_task_runner.h"
+
+using WebKit::WebWorkerRunLoop;
+
+namespace {
+
+class RunClosureTask : public WebKit::WebWorkerRunLoop::Task {
+ public:
+  RunClosureTask(const base::Closure& task) : task_(task) { }
+  virtual ~RunClosureTask() { }
+  virtual void Run() {
+    task_.Run();
+  }
+ private:
+  base::Closure task_;
+};
+
+}
+
+namespace webkit_glue {
+
+WorkerTaskRunner::WorkerTaskRunner() : id_sequence_(0) {
+}
+
+void WorkerTaskRunner::PostTask(
+    int id, const base::Closure& closure) {
+  DCHECK(id > 0);
+  base::AutoLock locker_(lock_);
+  IDToLoopMap::iterator found = loop_map_.find(id);
+  if (found != loop_map_.end())
+    found->second.postTask(new RunClosureTask(closure));
+}
+
+int WorkerTaskRunner::CurrentWorkerId() {
+  if (!current_tls_.Get())
+    return 0;
+  return current_tls_.Get()->first;
+}
+
+WorkerTaskRunner* WorkerTaskRunner::Instance() {
+  static base::LazyInstance<WorkerTaskRunner,
+      base::LeakyLazyInstanceTraits<WorkerTaskRunner> >
+      worker_task_runner_ = LAZY_INSTANCE_INITIALIZER;
+  return worker_task_runner_.Pointer();
+}
+
+void WorkerTaskRunner::AddObserver(Observer* obs) {
+  base::AutoLock locker(observer_lock_);
+  observer_list_.insert(obs);
+}
+
+int WorkerTaskRunner::RemoveObserver(Observer* obs) {
+  base::AutoLock locker(observer_lock_);
+  return observer_list_.erase(obs);
+}
+
+WorkerTaskRunner::~WorkerTaskRunner() {
+}
+
+void WorkerTaskRunner::OnWorkerRunLoopStarted(const WebWorkerRunLoop& loop) {
+  DCHECK(!current_tls_.Get());
+  {
+    base::AutoLock locker_(lock_);
+    int id = ++id_sequence_;
+    current_tls_.Set(new std::pair<int, WebWorkerRunLoop>(id, loop));
+    loop_map_[id] = loop;
+  }
+  observer_lock_.Acquire();
+  ObserverList observers_snapshot(observer_list_);
+  observer_lock_.Release();
+  for(ObserverList::iterator iter = observers_snapshot.begin();
+      iter != observers_snapshot.end(); iter++) {
+    (*iter)->OnWorkerRunLoopStarted();
+  }
+}
+
+void WorkerTaskRunner::OnWorkerRunLoopStopped(
+    const WebWorkerRunLoop& loop) {
+  DCHECK(CurrentWorkerId() > 0);
+  DCHECK(current_tls_.Get());
+  observer_lock_.Acquire();
+  ObserverList observers_snapshot(observer_list_);

[michaeln, 2011/12/09 20:45:34]

This still doesn't work. As coded it's more amenable to 'observers' with thread
affinity removing themselves in their stopped notification (but will break if
other observers that haven't been notified yet get removed). Also this creates a
larger problem for our intended use where long lived observers w/o thread
affinity (like IDBMessageFilter) are setup early on at init time and only
removed near the end of time. 

Let's rethink this?

I don't think we actually need the starting notification for our use case, we do
need the stopping notification and that does need to be called on the 'worker'
thread itself (so idb objects with thread affinity can get cleaned up on the
right thread).

What if instead we had this API...

WorkerTaskRunner {

  class StopObserver {
    OnStopping();
  };

  // Add/Remove an observer that will get notified when
  // the current worker run loop is stopping. This observer
  // will not get notified when other threads are stopping.
  // It's only valid to call these on a worker thread.
  // DCHECK(CurrentWorkerId());
  void AddStopObserverForCurrentWorker(obs);
  void RemoveStopObserverForCurrentWorker(obs);
};

When the IDBDispatcher is first created for worker thread, it can be added as a
stopping observer and can delete itself upon receiving that notification.

An instance of base::ObserverList would work for that per-thread collection of
StoppingObservers. No locking required.

Instead of putting a ptr to std::pair<int, WebWorkerRunLoop>, we could put a ptr
to an object with three items...

namespace {
class PerThreadState {
  int id;
  WebWorkerRunLoop loop;
  base::ObserverList stop_observers;
};
}

wdyt?

+  observer_lock_.Release();
+  for(ObserverList::iterator iter = observers_snapshot.begin();
+      iter != observers_snapshot.end(); iter++) {
+    (*iter)->OnWorkerRunLoopStopped();
+  }
+  base::AutoLock locker_(lock_);
+  DCHECK(loop_map_[CurrentWorkerId()] == loop);
+  loop_map_.erase(CurrentWorkerId());
+  delete current_tls_.Get();
+  current_tls_.Set(NULL);
+}
+
+}  // namespace webkit_glue