Rename WorkerContext to WorkerGlobalScope

Source/core/workers/WorkerRunLoop.cpp

 /*
  * 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 18 matching lines @@
  */
  
 #include "config.h"
 #include "core/workers/WorkerRunLoop.h"
 
 #include "bindings/v8/WorkerScriptController.h"
 #include "core/dom/ScriptExecutionContext.h"
 #include "core/platform/SharedTimer.h"
 #include "core/platform/ThreadGlobalData.h"
 #include "core/platform/ThreadTimers.h"
-#include "core/workers/WorkerContext.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerThread.h"
 #include <wtf/CurrentTime.h>
 
 namespace WebCore {
 
 class WorkerSharedTimer : public SharedTimer {
 public:
     WorkerSharedTimer()
         : m_sharedTimerFunction(0)
         , m_nextFireTime(0)
@@ skipping 70 matching lines @@
     ~RunLoopSetup()
     {
         m_runLoop.m_nestedCount--;
         if (!m_runLoop.m_nestedCount)
             threadGlobalData().threadTimers().setSharedTimer(0);
     }
 private:
     WorkerRunLoop& m_runLoop;
 };
 
-void WorkerRunLoop::run(WorkerContext* context)
+void WorkerRunLoop::run(WorkerGlobalScope* context)
 {
     RunLoopSetup setup(*this);
     ModePredicate modePredicate(defaultMode());
     MessageQueueWaitResult result;
     do {
         result = runInMode(context, modePredicate, WaitForMessage);
     } while (result != MessageQueueTerminated);
     runCleanupTasks(context);
 }
 
-MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerContext* context, const String& mode, WaitMode waitMode)
+MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerGlobalScope* context, const String& mode, WaitMode waitMode)
 {
     RunLoopSetup setup(*this);
     ModePredicate modePredicate(mode);
     MessageQueueWaitResult result = runInMode(context, modePredicate, waitMode);
     return result;
 }
 
-MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerContext* context, const ModePredicate& predicate, WaitMode waitMode)
+MessageQueueWaitResult WorkerRunLoop::runInMode(WorkerGlobalScope* context, const ModePredicate& predicate, WaitMode waitMode)
 {
     ASSERT(context);
     ASSERT(context->thread());
     ASSERT(context->thread()->isCurrentThread());
 
     double absoluteTime = 0.0;
     if (waitMode == WaitForMessage) {
         absoluteTime = (predicate.isDefaultMode() && m_sharedTimer->isActive()) ? m_sharedTimer->fireTime() : MessageQueue<Task>::infiniteTime();
         if (m_messageQueue.isEmpty()) {
             idleNotification(absoluteTime - currentTime());
@@ skipping 16 matching lines @@
 
     case MessageQueueTimeout:
         if (!context->isClosing() && currentTime() >= m_sharedTimer->fireTime())
             m_sharedTimer->fire();
         break;
     }
 
     return result;
 }
 
-void WorkerRunLoop::runCleanupTasks(WorkerContext* context)
+void WorkerRunLoop::runCleanupTasks(WorkerGlobalScope* context)
 {
     ASSERT(context);
     ASSERT(context->thread());
     ASSERT(context->thread()->isCurrentThread());
     ASSERT(m_messageQueue.killed());
 
     while (true) {
         OwnPtr<WorkerRunLoop::Task> task = m_messageQueue.tryGetMessageIgnoringKilled();
         if (!task)
             return;
@@ skipping 39 matching lines @@
     m_nextIdleNotificationTime = now + m_currentIdleIntervalInSeconds;
 }
 
 PassOwnPtr<WorkerRunLoop::Task> WorkerRunLoop::Task::create(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
 {
     return adoptPtr(new Task(task, mode));
 }
 
 void WorkerRunLoop::Task::performTask(const WorkerRunLoop& runLoop, ScriptExecutionContext* context)
 {
-    WorkerContext* workerContext = static_cast<WorkerContext *>(context);
-    if ((!workerContext->isClosing() && !runLoop.terminated()) || m_task->isCleanupTask())
+    WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(context);
+    if ((!workerGlobalScope->isClosing() && !runLoop.terminated()) || m_task->isCleanupTask())
         m_task->performTask(context);
 }
 
 WorkerRunLoop::Task::Task(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
     : m_task(task)
     , m_mode(mode.isolatedCopy())
 {
 }
 
 } // namespace WebCore