Rename WorkerContext to WorkerGlobalScope

Source/core/inspector/InspectorWorkerAgent.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 19 matching lines @@
 
 #include "config.h"
 
 #include "core/inspector/InspectorWorkerAgent.h"
 
 #include "InspectorFrontend.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/JSONParser.h"
 #include "core/platform/JSONValues.h"
-#include "core/workers/WorkerContextProxy.h"
+#include "core/workers/WorkerGlobalScopeProxy.h"
 #include "weborigin/KURL.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace WebCore {
 
 namespace WorkerAgentState {
 static const char workerInspectionEnabled[] = "workerInspectionEnabled";
 static const char autoconnectToWorkers[] = "autoconnectToWorkers";
 };
 
-class InspectorWorkerAgent::WorkerFrontendChannel : public WorkerContextProxy::PageInspector {
+class InspectorWorkerAgent::WorkerFrontendChannel : public WorkerGlobalScopeProxy::PageInspector {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    explicit WorkerFrontendChannel(InspectorFrontend* frontend, WorkerContextProxy* proxy)
+    explicit WorkerFrontendChannel(InspectorFrontend* frontend, WorkerGlobalScopeProxy* proxy)
         : m_frontend(frontend)
         , m_proxy(proxy)
         , m_id(s_nextId++)
         , m_connected(false)
     {
     }
     virtual ~WorkerFrontendChannel()
     {
-        disconnectFromWorkerContext();
+        disconnectFromWorkerGlobalScope();
     }
 
     int id() const { return m_id; }
-    WorkerContextProxy* proxy() const { return m_proxy; }
+    WorkerGlobalScopeProxy* proxy() const { return m_proxy; }
 
-    void connectToWorkerContext()
+    void connectToWorkerGlobalScope()
     {
         if (m_connected)
             return;
         m_connected = true;
         m_proxy->connectToInspector(this);
     }
 
-    void disconnectFromWorkerContext()
+    void disconnectFromWorkerGlobalScope()
     {
         if (!m_connected)
             return;
         m_connected = false;
         m_proxy->disconnectFromInspector();
     }
 
 private:
-    // WorkerContextProxy::PageInspector implementation
+    // WorkerGlobalScopeProxy::PageInspector implementation
     virtual void dispatchMessageFromWorker(const String& message)
     {
         RefPtr<JSONValue> value = parseJSON(message);
         if (!value)
             return;
         RefPtr<JSONObject> messageObject = value->asObject();
         if (!messageObject)
             return;
         m_frontend->worker()->dispatchMessageFromWorker(m_id, messageObject);
     }
 
     InspectorFrontend* m_frontend;
-    WorkerContextProxy* m_proxy;
+    WorkerGlobalScopeProxy* m_proxy;
     int m_id;
     bool m_connected;
     static int s_nextId;
 };
 
 int InspectorWorkerAgent::WorkerFrontendChannel::s_nextId = 1;
 
 PassOwnPtr<InspectorWorkerAgent> InspectorWorkerAgent::create(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* inspectorState)
 {
     return adoptPtr(new InspectorWorkerAgent(instrumentingAgents, inspectorState));
@@ skipping 47 matching lines @@
 
 void InspectorWorkerAgent::canInspectWorkers(ErrorString*, bool* result)
 {
     *result = true;
 }
 
 void InspectorWorkerAgent::connectToWorker(ErrorString* error, int workerId)
 {
     WorkerFrontendChannel* channel = m_idToChannel.get(workerId);
     if (channel)
-        channel->connectToWorkerContext();
+        channel->connectToWorkerGlobalScope();
     else
         *error = "Worker is gone";
 }
 
 void InspectorWorkerAgent::disconnectFromWorker(ErrorString* error, int workerId)
 {
     WorkerFrontendChannel* channel = m_idToChannel.get(workerId);
     if (channel)
-        channel->disconnectFromWorkerContext();
+        channel->disconnectFromWorkerGlobalScope();
     else
         *error = "Worker is gone";
 }
 
 void InspectorWorkerAgent::sendMessageToWorker(ErrorString* error, int workerId, const RefPtr<JSONObject>& message)
 {
     WorkerFrontendChannel* channel = m_idToChannel.get(workerId);
     if (channel)
         channel->proxy()->sendMessageToInspector(message->toJSONString());
     else
         *error = "Worker is gone";
 }
 
 void InspectorWorkerAgent::setAutoconnectToWorkers(ErrorString*, bool value)
 {
     m_state->setBoolean(WorkerAgentState::autoconnectToWorkers, value);
 }
 
 bool InspectorWorkerAgent::shouldPauseDedicatedWorkerOnStart()
 {
     return m_state->getBoolean(WorkerAgentState::autoconnectToWorkers);
 }
 
-void InspectorWorkerAgent::didStartWorkerContext(WorkerContextProxy* workerContextProxy, const KURL& url)
+void InspectorWorkerAgent::didStartWorkerGlobalScope(WorkerGlobalScopeProxy* workerGlobalScopeProxy, const KURL& url)
 {
-    m_dedicatedWorkers.set(workerContextProxy, url.string());
+    m_dedicatedWorkers.set(workerGlobalScopeProxy, url.string());
     if (m_inspectorFrontend && m_state->getBoolean(WorkerAgentState::workerInspectionEnabled))
-        createWorkerFrontendChannel(workerContextProxy, url.string());
+        createWorkerFrontendChannel(workerGlobalScopeProxy, url.string());
 }
 
-void InspectorWorkerAgent::workerContextTerminated(WorkerContextProxy* proxy)
+void InspectorWorkerAgent::workerGlobalScopeTerminated(WorkerGlobalScopeProxy* proxy)
 {
     m_dedicatedWorkers.remove(proxy);
     for (WorkerChannels::iterator it = m_idToChannel.begin(); it != m_idToChannel.end(); ++it) {
         if (proxy == it->value->proxy()) {
             m_inspectorFrontend->worker()->workerTerminated(it->key);
             delete it->value;
             m_idToChannel.remove(it);
             return;
         }
     }
 }
 
 void InspectorWorkerAgent::createWorkerFrontendChannelsForExistingWorkers()
 {
     for (DedicatedWorkers::iterator it = m_dedicatedWorkers.begin(); it != m_dedicatedWorkers.end(); ++it)
         createWorkerFrontendChannel(it->key, it->value);
 }
 
 void InspectorWorkerAgent::destroyWorkerFrontendChannels()
 {
     for (WorkerChannels::iterator it = m_idToChannel.begin(); it != m_idToChannel.end(); ++it) {
-        it->value->disconnectFromWorkerContext();
+        it->value->disconnectFromWorkerGlobalScope();
         delete it->value;
     }
     m_idToChannel.clear();
 }
 
-void InspectorWorkerAgent::createWorkerFrontendChannel(WorkerContextProxy* workerContextProxy, const String& url)
+void InspectorWorkerAgent::createWorkerFrontendChannel(WorkerGlobalScopeProxy* workerGlobalScopeProxy, const String& url)
 {
-    WorkerFrontendChannel* channel = new WorkerFrontendChannel(m_inspectorFrontend, workerContextProxy);
+    WorkerFrontendChannel* channel = new WorkerFrontendChannel(m_inspectorFrontend, workerGlobalScopeProxy);
     m_idToChannel.set(channel->id(), channel);
 
     ASSERT(m_inspectorFrontend);
     bool autoconnectToWorkers = m_state->getBoolean(WorkerAgentState::autoconnectToWorkers);
     if (autoconnectToWorkers)
-        channel->connectToWorkerContext();
+        channel->connectToWorkerGlobalScope();
     m_inspectorFrontend->worker()->workerCreated(channel->id(), url, autoconnectToWorkers);
 }
 
 } // namespace WebCore