Oilpan: Prepare moving InspectorController and InspectorAgents to oilpan.

Source/core/inspector/WorkerDebuggerAgent.cpp

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/WorkerDebuggerAgent.h"
 
 #include "bindings/v8/ScriptDebugServer.h"
+#include "core/inspector/WorkerInspectorController.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerThread.h"
 #include "wtf/MessageQueue.h"
 
 namespace WebCore {
 
 namespace {
 
-Mutex& workerDebuggerAgentsMutex()
-{
-    AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
-    return mutex;
-}
-
-typedef HashMap<WorkerThread*, WorkerDebuggerAgent*> WorkerDebuggerAgents;
-
-WorkerDebuggerAgents& workerDebuggerAgents()
-{
-    DEFINE_STATIC_LOCAL(WorkerDebuggerAgents, agents, ());
-    return agents;
-}
-
-
 class RunInspectorCommandsTask FINAL : public ScriptDebugServer::Task {
 public:
     explicit RunInspectorCommandsTask(WorkerThread* thread)
         : m_thread(thread) { }
     virtual ~RunInspectorCommandsTask() { }
     virtual void run() OVERRIDE
     {
         // Process all queued debugger commands. WorkerThread is certainly
         // alive if this task is being executed.
         while (MessageQueueMessageReceived == m_thread->runLoop().runDebuggerTask(WorkerRunLoop::DontWaitForMessage)) { }
     }
 
 private:
     WorkerThread* m_thread;
 };
 
 } // namespace
 
-PassOwnPtr<WorkerDebuggerAgent> WorkerDebuggerAgent::create(WorkerScriptDebugServer* scriptDebugServer, WorkerGlobalScope* inspectedWorkerGlobalScope, InjectedScriptManager* injectedScriptManager)
+PassOwnPtrWillBeRawPtr<WorkerDebuggerAgent> WorkerDebuggerAgent::create(WorkerScriptDebugServer* scriptDebugServer, WorkerGlobalScope* inspectedWorkerGlobalScope, InjectedScriptManager* injectedScriptManager)
 {
-    return adoptPtr(new WorkerDebuggerAgent(scriptDebugServer, inspectedWorkerGlobalScope, injectedScriptManager));
+    return adoptPtrWillBeNoop(new WorkerDebuggerAgent(scriptDebugServer, inspectedWorkerGlobalScope, injectedScriptManager));
 }
 
 WorkerDebuggerAgent::WorkerDebuggerAgent(WorkerScriptDebugServer* scriptDebugServer, WorkerGlobalScope* inspectedWorkerGlobalScope, InjectedScriptManager* injectedScriptManager)
     : InspectorDebuggerAgent(injectedScriptManager)
     , m_scriptDebugServer(scriptDebugServer)
     , m_inspectedWorkerGlobalScope(inspectedWorkerGlobalScope)
 {
-    MutexLocker lock(workerDebuggerAgentsMutex());
-    workerDebuggerAgents().set(inspectedWorkerGlobalScope->thread(), this);
 }
 
 WorkerDebuggerAgent::~WorkerDebuggerAgent()
 {
-    MutexLocker lock(workerDebuggerAgentsMutex());
-    ASSERT(workerDebuggerAgents().contains(m_inspectedWorkerGlobalScope->thread()));
-    workerDebuggerAgents().remove(m_inspectedWorkerGlobalScope->thread());
+}
+
+void WorkerDebuggerAgent::trace(Visitor* visitor)
+{
+    visitor->trace(m_inspectedWorkerGlobalScope);
+    InspectorDebuggerAgent::trace(visitor);
 }
 
 void WorkerDebuggerAgent::interruptAndDispatchInspectorCommands(WorkerThread* thread)
 {
-    MutexLocker lock(workerDebuggerAgentsMutex());
-    WorkerDebuggerAgent* agent = workerDebuggerAgents().get(thread);
-    if (agent)
-        agent->m_scriptDebugServer->interruptAndRunTask(adoptPtr(new RunInspectorCommandsTask(thread)));
+    WorkerGlobalScope* workerGlobalScope = thread->workerGlobalScope();
+    if (!workerGlobalScope)

[yurys, 2014/06/19 07:37:03]

This method is called on the main thread while WorkerGlobalScope is created and
destroyed on the worker thread. It may well happen now that WorkerGlobalScope is
getting destroyed while we are using it in this method. Is there a reason we
cannot leave previous implementation that used a map guarded by a mutex?

[keishi, 2014/06/19 12:52:07]

I was able to make the map solution work in oilpan in patch set 11.
https://codereview.chromium.org/307943002/diff/220001/Source/core/inspector/W...

There are limitations related to threads with oilpan's handles (discussed in
previous comments) and that made the type of the map quite complicated. I was
trying if there was a simpler way.

In the new patch I've added a pointer to WebThread and added a mutex so we don't
destruct and call this function at the same time. 

I could go back to the map if you'd like.

+        return;
+    WorkerInspectorController* workerInspectorController = workerGlobalScope->workerInspectorController();
+    ASSERT(workerInspectorController);
+    WorkerDebuggerAgent* workerDebuggerAgent = workerInspectorController->workerDebuggerAgent();
+    ASSERT(workerDebuggerAgent);
+    workerDebuggerAgent->scriptDebugServer().interruptAndRunTask(adoptPtr(new RunInspectorCommandsTask(thread)));
 }
 
 void WorkerDebuggerAgent::startListeningScriptDebugServer()
 {
     scriptDebugServer().addListener(this);
 }
 
 void WorkerDebuggerAgent::stopListeningScriptDebugServer()
 {
     scriptDebugServer().removeListener(this);
@@ skipping 17 matching lines @@
 {
     // We don't need to mute console for workers.
 }
 
 void WorkerDebuggerAgent::unmuteConsole()
 {
     // We don't need to mute console for workers.
 }
 
 } // namespace WebCore