Rename WorkerContext to WorkerGlobalScope

Source/core/workers/WorkerRunLoop.h

 /*
  * Copyright (C) 2009 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 21 matching lines @@
 #define WorkerRunLoop_h
 
 #include "core/dom/ScriptExecutionContext.h"
 #include <wtf/MessageQueue.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
 
     class ModePredicate;
-    class WorkerContext;
+    class WorkerGlobalScope;
     class WorkerSharedTimer;
 
     class WorkerRunLoop {
     public:
         WorkerRunLoop();
         ~WorkerRunLoop();
         
         // Blocking call. Waits for tasks and timers, invokes the callbacks.
-        void run(WorkerContext*);
+        void run(WorkerGlobalScope*);
 
         enum WaitMode { WaitForMessage, DontWaitForMessage };
 
         // Waits for a single task and returns.
-        MessageQueueWaitResult runInMode(WorkerContext*, const String& mode, WaitMode = WaitForMessage);
+        MessageQueueWaitResult runInMode(WorkerGlobalScope*, const String& mode, WaitMode = WaitForMessage);
 
         void terminate();
         bool terminated() const { return m_messageQueue.killed(); }
 
         void postTask(PassOwnPtr<ScriptExecutionContext::Task>);
         void postTaskAndTerminate(PassOwnPtr<ScriptExecutionContext::Task>);
         void postTaskForMode(PassOwnPtr<ScriptExecutionContext::Task>, const String& mode);
 
         unsigned long createUniqueId() { return ++m_uniqueId; }
 
         static String defaultMode();
 
         class Task {
             WTF_MAKE_NONCOPYABLE(Task); WTF_MAKE_FAST_ALLOCATED;
         public:
             static PassOwnPtr<Task> create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode);
             ~Task() { }
             const String& mode() const { return m_mode; }
             void performTask(const WorkerRunLoop&, ScriptExecutionContext*);
 
         private:
             Task(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode);
         
             OwnPtr<ScriptExecutionContext::Task> m_task;
             String m_mode;
         };
 
     private:
         friend class RunLoopSetup;
-        MessageQueueWaitResult runInMode(WorkerContext*, const ModePredicate&, WaitMode);
+        MessageQueueWaitResult runInMode(WorkerGlobalScope*, const ModePredicate&, WaitMode);
 
         // Runs any clean up tasks that are currently in the queue and returns.
         // This should only be called when the context is closed or loop has been terminated.
-        void runCleanupTasks(WorkerContext*);
+        void runCleanupTasks(WorkerGlobalScope*);
 
         void idleNotification(double idlenessInterval);
 
         MessageQueue<Task> m_messageQueue;
         OwnPtr<WorkerSharedTimer> m_sharedTimer;
         int m_nestedCount;
         unsigned long m_uniqueId;
         double m_currentIdleIntervalInSeconds;
         double m_nextIdleNotificationTime;
     };
 
 } // namespace WebCore
 
 #endif // WorkerRunLoop_h