Worker: Reorder function definitions of WorkerThread

third_party/WebKit/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 66 matching lines @@
     virtual WorkerBackingThread& workerBackingThread() = 0;
     virtual bool shouldAttachThreadDebugger() const { return true; }
     v8::Isolate* isolate();
 
     // Can be used to wait for this worker thread to terminate.
     // (This is signaled on the main thread, so it's assumed to be waited on
     // the worker context thread)
     WaitableEvent* terminationEvent() { return m_terminationEvent.get(); }
 
     bool isCurrentThread();
+
     WorkerLoaderProxy* workerLoaderProxy() const
     {
         RELEASE_ASSERT(m_workerLoaderProxy);
         return m_workerLoaderProxy.get();
     }
 
     WorkerReportingProxy& workerReportingProxy() const { return m_workerReportingProxy; }
 
     void postTask(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>);
     void appendDebuggerTask(std::unique_ptr<CrossThreadClosure>);
@@ skipping 24 matching lines @@
     virtual WorkerGlobalScope* createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData>) = 0;
 
     // Called on the worker thread.
     virtual void postInitialize() { }
 
 private:
     class WorkerMicrotaskRunner;
 
     std::unique_ptr<CrossThreadClosure> createWorkerThreadTask(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
 
-    // Called on the worker thread.
-    void initialize(PassOwnPtr<WorkerThreadStartupData>);
-    void performTask(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
-    void prepareForShutdown();
-    void performShutdown();
-    void runDebuggerTask(std::unique_ptr<CrossThreadClosure>);
-    void runDebuggerTaskDontWait();
+    void initializeOnWorkerThread(PassOwnPtr<WorkerThreadStartupData>);
+    void prepareForShutdownOnWorkerThread();
+    void performShutdownOnWorkerThread();
+    void performTaskOnWorkerThread(std::unique_ptr<ExecutionContextTask>, bool isInstrumented);
+    void runDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure>);
+    void runDebuggerTaskDontWaitOnWorkerThread();
 
     bool m_started = false;
     bool m_terminated = false;
     bool m_readyToShutdown = false;
     bool m_pausedInDebugger = false;
     bool m_runningDebuggerTask = false;
     bool m_shouldTerminateV8Execution = false;
 
     OwnPtr<InspectorTaskRunner> m_inspectorTaskRunner;
     OwnPtr<WorkerMicrotaskRunner> m_microtaskRunner;
@@ skipping 11 matching lines @@
     // Signaled when the thread starts termination on the main thread.
     OwnPtr<WaitableEvent> m_terminationEvent;
 
     // Signaled when the thread completes termination on the worker thread.
     OwnPtr<WaitableEvent> m_shutdownEvent;
 };
 
 } // namespace blink
 
 #endif // WorkerThread_h