Worker: Rename worker components to clarify what they work for

third_party/WebKit/Source/core/workers/InProcessWorkerMessagingProxy.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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
-#ifndef WorkerMessagingProxy_h
-#define WorkerMessagingProxy_h
+#ifndef InProcessWorkerMessagingProxy_h
+#define InProcessWorkerMessagingProxy_h
 
 #include "core/CoreExport.h"
 #include "core/dom/ExecutionContext.h"
-#include "core/workers/WorkerGlobalScopeProxy.h"
+#include "core/workers/InProcessWorkerGlobalScopeProxy.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class WorkerObjectProxy;
 class WorkerThread;
 class ExecutionContext;
 class InProcessWorkerBase;
 class WorkerClients;
 class WorkerInspectorProxy;
 
-class CORE_EXPORT WorkerMessagingProxy
-    : public WorkerGlobalScopeProxy
+// TODO(nhiroki): "MessagingProxy" is not well-defined term among worker
+// components. Probably we should rename this to something more suitable.
+// (http://crbug.com/603785)
+class CORE_EXPORT InProcessWorkerMessagingProxy
+    : public InProcessWorkerGlobalScopeProxy
     , private WorkerLoaderProxyProvider {
-    WTF_MAKE_NONCOPYABLE(WorkerMessagingProxy);
+    WTF_MAKE_NONCOPYABLE(InProcessWorkerMessagingProxy);
 public:
-    // Implementations of WorkerGlobalScopeProxy.
+    // Implementations of InProcessWorkerGlobalScopeProxy.
     // (Only use these methods in the worker object thread.)
     void startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode) override;
     void terminateWorkerGlobalScope() override;
     void postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>) override;
     bool hasPendingActivity() const final;
     void workerObjectDestroyed() override;
 
     // These methods come from worker context thread via WorkerObjectProxy
     // and are called on the worker object thread (e.g. main thread).
     void postMessageToWorkerObject(PassRefPtr<SerializedScriptValue>, PassOwnPtr<MessagePortChannelArray>);
     void reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, int exceptionId);
     void reportConsoleMessage(MessageSource, MessageLevel, const String& message, int lineNumber, const String& sourceURL);
     void postMessageToPageInspector(const String&);
     void postWorkerConsoleAgentEnabled();
     void confirmMessageFromWorkerObject(bool hasPendingActivity);
     void reportPendingActivity(bool hasPendingActivity);
     void workerGlobalScopeClosed();
     void workerThreadTerminated();
     void workerThreadCreated();
 
     ExecutionContext* getExecutionContext() const { return m_executionContext.get(); }
 
 protected:
-    WorkerMessagingProxy(InProcessWorkerBase*, WorkerClients*);
-    ~WorkerMessagingProxy() override;
+    InProcessWorkerMessagingProxy(InProcessWorkerBase*, WorkerClients*);
+    ~InProcessWorkerMessagingProxy() override;
 
     virtual PassOwnPtr<WorkerThread> createWorkerThread(double originTime) = 0;
 
     PassRefPtr<WorkerLoaderProxy> loaderProxy() { return m_loaderProxy; }
     WorkerObjectProxy& workerObjectProxy() { return *m_workerObjectProxy.get(); }
 
 private:
     void workerObjectDestroyedInternal();
     void terminateInternally();
 
@@ skipping 17 matching lines @@
     Vector<OwnPtr<ExecutionContextTask>> m_queuedEarlyTasks; // Tasks are queued here until there's a thread object created.
     Persistent<WorkerInspectorProxy> m_workerInspectorProxy;
 
     Persistent<WorkerClients> m_workerClients;
 
     RefPtr<WorkerLoaderProxy> m_loaderProxy;
 };
 
 } // namespace blink
 
-#endif // WorkerMessagingProxy_h
+#endif // InProcessWorkerMessagingProxy_h