workers: Move ownership of WebThread from WorkerThread

Source/core/workers/WorkerThread.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 141 matching lines @@
 
     v8::Isolate* m_isolate;
     OwnPtr<V8IsolateInterruptor> m_interruptor;
 
     // Used to signal thread shutdown.
     OwnPtr<WebWaitableEvent> m_shutdownEvent;
 
     // Used to signal thread termination.
     OwnPtr<WebWaitableEvent> m_terminationEvent;
 
+    WebThreadSupportingGC* m_thread;
+
     // FIXME: This has to be last because of crbug.com/401397 - the
     // WorkerThread might get deleted before it had a chance to properly
     // shut down. By deleting the WebThread first, we can guarantee that
     // no pending tasks on the thread might want to access any of the other
     // members during the WorkerThread's destruction.
-    OwnPtr<WebThreadSupportingGC> m_thread;
+    OwnPtr<WebThreadSupportingGC> m_ownThread;

[kinuko, 2015/04/27 06:02:58]

The relationship between m_thread and m_ownThread seems confusing, would it be
like the first WebThread creates a thread and owns it, and other WebThread's
will be reusing it? Can you briefly explain when and how and when a 'real'
thread is created and managed? Could we not to have both m_thread and
m_ownThread?

Also (as is mentioned in some other thread before) the name 'WorkerThread' is
becoming very confusing if it doesn't really mean a thread.

[sadrul, 2015/04/27 07:05:29]

The idea is that for compositor workers, there will be a single
CompositorWorkerManager, which is responsible for managing the single
WebThreadSupportingGC used for all the CompositorWorkerThreads. So none of the
CompositorWorkerThreads actually owns the WebThread* instance,
CompositorWorkerManager does.
One option (in fact the option I went with initially) is to move the ownership
of the WebThreadSupportingGC out of WorkerThread. For shared/dedicated/service
WorkerThread implementations, the corresponding sub-class would create and own
the WebThreadSupportingGC, and WorkerThread would access that through a virtual
thread() function. That would also allow CompositorWorkerThreads to share the
same WebThreadSupportingGC. Would that make this clearer?
Perhaps WorkerScript would be more appropriate?

 };
 
 } // namespace blink
 
 #endif // WorkerThread_h