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
128
129
130
131
132
|
/* -*- 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;
}
// Last reference is freed in DeallocPVsyncBridgeChild.
AddRef();
}
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::ActorDealloc() { Release(); }
void VsyncBridgeChild::ProcessingError(Result aCode, const char* aReason) {
MOZ_RELEASE_ASSERT(aCode == MsgDropped,
"Processing error in VsyncBridgeChild");
}
void VsyncBridgeChild::HandleFatalError(const char* aMsg) const {
dom::ContentChild::FatalErrorIfNotUsingGPUProcess(aMsg, OtherPid());
}
} // namespace gfx
} // namespace mozilla
|
