1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ThreadedMessagingProxyBase_h
#define ThreadedMessagingProxyBase_h
#include "core/CoreExport.h"
#include "core/frame/UseCounter.h"
#include "core/inspector/ConsoleTypes.h"
#include "core/workers/WorkerLoaderProxy.h"
#include "wtf/Forward.h"
namespace blink {
class ExecutionContext;
class ParentFrameTaskRunners;
class SourceLocation;
class WorkerInspectorProxy;
class WorkerLoaderProxy;
class WorkerThread;
class WorkerThreadStartupData;
class CORE_EXPORT ThreadedMessagingProxyBase
: private WorkerLoaderProxyProvider {
public:
void terminateGlobalScope();
virtual void workerThreadCreated();
// This method should be called in the destructor of the object which
// initially created it. This object could either be a Worker or a Worklet.
virtual void parentObjectDestroyed();
void countFeature(UseCounter::Feature);
void countDeprecation(UseCounter::Feature);
void reportConsoleMessage(MessageSource,
MessageLevel,
const String& message,
std::unique_ptr<SourceLocation>);
void postMessageToPageInspector(const String&);
// 'virtual' for testing.
virtual void workerThreadTerminated();
ExecutionContext* getExecutionContext() const {
return m_executionContext.get();
}
ParentFrameTaskRunners* getParentFrameTaskRunners() {
return m_parentFrameTaskRunners.get();
}
// Number of live messaging proxies, used by leak detection.
static int proxyCount();
protected:
ThreadedMessagingProxyBase(ExecutionContext*);
~ThreadedMessagingProxyBase() override;
void initializeWorkerThread(std::unique_ptr<WorkerThreadStartupData>);
virtual std::unique_ptr<WorkerThread> createWorkerThread(
double originTime) = 0;
WorkerThread* workerThread() const { return m_workerThread.get(); }
bool askedToTerminate() const { return m_askedToTerminate; }
PassRefPtr<WorkerLoaderProxy> loaderProxy() { return m_loaderProxy; }
WorkerInspectorProxy* workerInspectorProxy() {
return m_workerInspectorProxy.get();
}
// Returns true if this is called on the parent context thread.
bool isParentContextThread() const;
// WorkerLoaderProxyProvider
// These methods are called on different threads to schedule loading
// requests and to send callbacks back to WorkerGlobalScope.
void postTaskToLoader(const WebTraceLocation&,
std::unique_ptr<ExecutionContextTask>) override;
void postTaskToWorkerGlobalScope(
const WebTraceLocation&,
std::unique_ptr<WTF::CrossThreadClosure>) override;
private:
friend class InProcessWorkerMessagingProxyForTest;
friend class ThreadedWorkletMessagingProxyForTest;
void parentObjectDestroyedInternal();
Persistent<ExecutionContext> m_executionContext;
Persistent<WorkerInspectorProxy> m_workerInspectorProxy;
Persistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
std::unique_ptr<WorkerThread> m_workerThread;
RefPtr<WorkerLoaderProxy> m_loaderProxy;
bool m_mayBeDestroyed;
bool m_askedToTerminate;
};
} // namespace blink
#endif // ThreadedMessagingProxyBase_h
|
