Track webcore worker message loops in chromium.

content/common/child_thread.h

 // 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.
 
 #ifndef CONTENT_COMMON_CHILD_THREAD_H_
 #define CONTENT_COMMON_CHILD_THREAD_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "content/common/content_export.h"
 #include "content/common/message_router.h"
 #include "webkit/glue/resource_loader_bridge.h"
 
 class FileSystemDispatcher;
 class MessageLoop;
 class QuotaDispatcher;
 class ResourceDispatcher;
 class SocketStreamDispatcher;
+class WorkerTaskRunner;
 
 namespace IPC {
 class SyncChannel;
 class SyncMessageFilter;
 }
 
 // The main thread of a child process derives from this class.
 class CONTENT_EXPORT ChildThread : public IPC::Channel::Listener,
                                    public IPC::Message::Sender {
  public:
@@ skipping 41 matching lines @@
 
   // Safe to call on any thread, as long as it's guaranteed that the thread's
   // lifetime is less than the main thread.
   IPC::SyncMessageFilter* sync_message_filter();
 
   MessageLoop* message_loop();
 
   // Returns the one child thread.
   static ChildThread* current();
 
+  WorkerTaskRunner* worker_task_runner() const;
+
  protected:
   friend class ChildProcess;
 
   // Called when the process refcount is 0.
   void OnProcessFinalRelease();
 
   virtual bool OnControlMessageReceived(const IPC::Message& msg);
   virtual void OnAskBeforeShutdown();
   virtual void OnShutdown();
 
@@ skipping 41 matching lines @@
   // The OnChannelError() callback was invoked - the channel is dead, don't
   // attempt to communicate.
   bool on_channel_error_called_;
 
   MessageLoop* message_loop_;
 
   scoped_ptr<FileSystemDispatcher> file_system_dispatcher_;
 
   scoped_ptr<QuotaDispatcher> quota_dispatcher_;
 
+  scoped_refptr<WorkerTaskRunner> worker_task_runner_;

[michaeln, 2011/12/05 22:02:09]

Would a leaky lazy instance be a safer/better choice for the worker task runner?
As coded in this CL, the refcounted'ness isn't used. Also do you know if worker
threads are guaranteed to be shutdown at ChildThread dtor time?

[dgrogan, 2011/12/06 00:15:15]

Not having to worry about the lifetime would be nice.  Less code, etc.
I don't think they are guaranteed to be shutdown at ChildThread dtor time.

----

After looking into this, LazyInstance seems to not add anything because
IndexedDBMessageFilter will add itself as an observer right after construction,
which is in the ChildThread ctor.  How about leaking it by removing the ref
counting and replacing scoped_refptr<WorkerTaskRunner> with WorkerTaskRunner*?

+
   DISALLOW_COPY_AND_ASSIGN(ChildThread);
 };
 
 #endif  // CONTENT_COMMON_CHILD_THREAD_H_