[WIP]Implement Blink side changes for navigator.language(s) support for workers.

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 13 matching lines @@
  *
  */
 
 #ifndef WorkerThread_h
 #define WorkerThread_h
 
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/SharedTimer.h"
-#include "platform/WebThreadSupportingGC.h"
+#include "platform/heap/glue/MessageLoopInterruptor.h"
+#include "platform/heap/glue/PendingGCRunner.h"
 #include "platform/weborigin/SecurityOrigin.h"
+#include "public/platform/WebThread.h"
 #include "wtf/Forward.h"
 #include "wtf/MessageQueue.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 
 namespace blink {
 class WebWaitableEvent;
 }
 
@@ skipping 44 matching lines @@
         WorkerGlobalScope* workerGlobalScope() const { return m_workerGlobalScope.get(); }
         bool terminated() const { return m_terminated; }
 
         // Number of active worker threads.
         static unsigned workerThreadCount();
 
         PlatformThreadId platformThreadId() const;
 
         void interruptAndDispatchInspectorCommands();
         void setWorkerInspectorController(WorkerInspectorController*);
+        void postTaskLanguageChanged();
+        // static void notifyAcceptLanguagesChanged(const String& newLanguagesList);
+        static void notifyAcceptLanguagesChanged(const Vector<String>& newLanguagesList);
 
     protected:
         WorkerThread(WorkerLoaderProxy&, WorkerReportingProxy&, PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>);
 
         // Factory method for creating a new worker context for the thread.
         virtual PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtrWillBeRawPtr<WorkerThreadStartupData>) = 0;
 
         virtual void postInitialize() { }
 
     private:
         friend class WorkerSharedTimer;
         friend class WorkerThreadShutdownFinishTask;
 
         void stopInShutdownSequence();
         void stopInternal();
 
         void initialize();
         void cleanup();
         void idleHandler();
         void postDelayedTask(PassOwnPtr<ExecutionContextTask>, long long delayMs);
 
         bool m_terminated;
         OwnPtr<WorkerSharedTimer> m_sharedTimer;
         MessageQueue<WorkerThreadTask> m_debuggerMessageQueue;
+        OwnPtr<PendingGCRunner> m_pendingGCRunner;
         OwnPtr<WebThread::TaskObserver> m_microtaskRunner;
+        OwnPtr<MessageLoopInterruptor> m_messageLoopInterruptor;
 
         WorkerLoaderProxy& m_workerLoaderProxy;
         WorkerReportingProxy& m_workerReportingProxy;
 
         RefPtrWillBePersistent<WorkerInspectorController> m_workerInspectorController;
         Mutex m_workerInspectorControllerMutex;
 
         Mutex m_threadCreationMutex;
         RefPtrWillBePersistent<WorkerGlobalScope> m_workerGlobalScope;
         OwnPtrWillBePersistent<WorkerThreadStartupData> m_startupData;
 
         // Used to signal thread shutdown.
         OwnPtr<blink::WebWaitableEvent> m_shutdownEvent;
 
         // Used to signal thread termination.
         OwnPtr<blink::WebWaitableEvent> m_terminationEvent;
 
         // 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<blink::WebThread> m_thread;
     };
 
 } // namespace blink
 
 #endif // WorkerThread_h