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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "VsyncBridgeChild.h"
#include "VsyncIOThreadHolder.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/gfx/GPUProcessManager.h"
#include "mozilla/ipc/Endpoint.h"
namespace mozilla {
namespace gfx {
VsyncBridgeChild::VsyncBridgeChild(RefPtr<VsyncIOThreadHolder> aThread,
const uint64_t& aProcessToken)
: mThread(aThread), mProcessToken(aProcessToken) {}
VsyncBridgeChild::~VsyncBridgeChild() = default;
/* static */
RefPtr<VsyncBridgeChild> VsyncBridgeChild::Create(
RefPtr<VsyncIOThreadHolder> aThread, const uint64_t& aProcessToken,
Endpoint<PVsyncBridgeChild>&& aEndpoint) {
RefPtr<VsyncBridgeChild> child = new VsyncBridgeChild(aThread, aProcessToken);
RefPtr<nsIRunnable> task = NewRunnableMethod<Endpoint<PVsyncBridgeChild>&&>(
"gfx::VsyncBridgeChild::Open", child, &VsyncBridgeChild::Open,
std::move(aEndpoint));
aThread->GetThread()->Dispatch(task.forget(), nsIThread::DISPATCH_NORMAL);
return child;
}
void VsyncBridgeChild::Open(Endpoint<PVsyncBridgeChild>&& aEndpoint) {
if (!aEndpoint.Bind(this)) {
// The GPU Process Manager might be gone if we receive ActorDestroy very
// late in shutdown.
if (GPUProcessManager* gpm = GPUProcessManager::Get())
gpm->NotifyRemoteActorDestroyed(mProcessToken);
return;
}
}
class NotifyVsyncTask : public Runnable {
public:
NotifyVsyncTask(RefPtr<VsyncBridgeChild> aVsyncBridge,
const VsyncEvent& aVsync, const layers::LayersId& aLayersId)
: Runnable("gfx::NotifyVsyncTask"),
mVsyncBridge(aVsyncBridge),
mVsync(aVsync),
mLayersId(aLayersId) {}
NS_IMETHOD Run() override {
mVsyncBridge->NotifyVsyncImpl(mVsync, mLayersId);
return NS_OK;
}
private:
RefPtr<VsyncBridgeChild> mVsyncBridge;
VsyncEvent mVsync;
layers::LayersId mLayersId;
};
bool VsyncBridgeChild::IsOnVsyncIOThread() const {
return mThread->IsOnCurrentThread();
}
void VsyncBridgeChild::NotifyVsync(const VsyncEvent& aVsync,
const layers::LayersId& aLayersId) {
// This should be on the Vsync thread (not the Vsync I/O thread).
MOZ_ASSERT(!IsOnVsyncIOThread());
RefPtr<NotifyVsyncTask> task = new NotifyVsyncTask(this, aVsync, aLayersId);
mThread->Dispatch(task.forget());
}
void VsyncBridgeChild::NotifyVsyncImpl(const VsyncEvent& aVsync,
const layers::LayersId& aLayersId) {
// This should be on the Vsync I/O thread.
MOZ_ASSERT(IsOnVsyncIOThread());
if (!mProcessToken) {
return;
}
SendNotifyVsync(aVsync, aLayersId);
}
void VsyncBridgeChild::Close() {
if (!IsOnVsyncIOThread()) {
mThread->Dispatch(NewRunnableMethod("gfx::VsyncBridgeChild::Close", this,
&VsyncBridgeChild::Close));
return;
}
// We clear mProcessToken when the channel is closed.
if (!mProcessToken) {
return;
}
// Clear the process token so we don't notify the GPUProcessManager. It
// already knows we're closed since it manually called Close, and in fact the
// GPM could have already been destroyed during shutdown.
mProcessToken = 0;
// Close the underlying IPC channel.
PVsyncBridgeChild::Close();
}
void VsyncBridgeChild::ActorDestroy(ActorDestroyReason aWhy) {
if (mProcessToken) {
GPUProcessManager::Get()->NotifyRemoteActorDestroyed(mProcessToken);
mProcessToken = 0;
}
}
void VsyncBridgeChild::ProcessingError(Result aCode, const char* aReason) {
MOZ_RELEASE_ASSERT(aCode == MsgDropped,
"Processing error in VsyncBridgeChild");
}
void VsyncBridgeChild::HandleFatalError(const char* aMsg) {
dom::ContentChild::FatalErrorIfNotUsingGPUProcess(aMsg, OtherPid());
}
} // namespace gfx
} // namespace mozilla
|
