blob: ca5b8640088bc3f354ea7bace3afae341b3b622a (
plain)
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/* -*- 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 https://mozilla.org/MPL/2.0/. */
#ifndef mozilla_layers_CanvasChild_h
#define mozilla_layers_CanvasChild_h
#include "mozilla/gfx/RecordedEvent.h"
#include "mozilla/ipc/CrossProcessSemaphore.h"
#include "mozilla/layers/PCanvasChild.h"
#include "mozilla/layers/SourceSurfaceSharedData.h"
#include "nsRefPtrHashtable.h"
#include "nsTArray.h"
namespace mozilla {
namespace gfx {
class SourceSurface;
}
namespace layers {
class CanvasDrawEventRecorder;
class CanvasChild final : public PCanvasChild {
public:
NS_INLINE_DECL_REFCOUNTING(CanvasChild)
explicit CanvasChild(Endpoint<PCanvasChild>&& aEndpoint);
/**
* @returns true if remote canvas has been deactivated due to failure.
*/
static bool Deactivated() { return mDeactivated; }
ipc::IPCResult RecvNotifyDeviceChanged();
ipc::IPCResult RecvDeactivate();
/**
* Ensures that the DrawEventRecorder has been created.
*
* @params aTextureType the TextureType to create in the CanvasTranslator.
*/
void EnsureRecorder(TextureType aTextureType);
/**
* Send a messsage to our CanvasParent to resume translation.
*/
void ResumeTranslation();
/**
* Clean up IPDL actor.
*/
void Destroy();
/**
* Called when a RecordedTextureData is write locked.
*/
void OnTextureWriteLock();
/**
* Called when a RecordedTextureData is forwarded to the compositor.
*/
void OnTextureForwarded();
/**
* @returns true if we should be caching data surfaces in the GPU process.
*/
bool ShouldCacheDataSurface() const {
return mTransactionsSinceGetDataSurface < kCacheDataSurfaceThreshold;
}
/**
* Ensures that we have sent a begin transaction event, since the last
* end transaction.
*/
void EnsureBeginTransaction();
/**
* Send an end transaction event to indicate the end of events for this frame.
*/
void EndTransaction();
/**
* @returns true if the canvas IPC classes have not been used for some time
* and can be cleaned up.
*/
bool ShouldBeCleanedUp() const;
/**
* Create a DrawTargetRecording for a canvas texture.
* @param aSize size for the DrawTarget
* @param aFormat SurfaceFormat for the DrawTarget
* @returns newly created DrawTargetRecording
*/
already_AddRefed<gfx::DrawTarget> CreateDrawTarget(
gfx::IntSize aSize, gfx::SurfaceFormat aFormat);
/**
* Record an event for processing by the CanvasParent's CanvasTranslator.
* @param aEvent the event to record
*/
void RecordEvent(const gfx::RecordedEvent& aEvent);
/**
* Wrap the given surface, so that we can provide a DataSourceSurface if
* required.
* @param aSurface the SourceSurface to wrap
* @returns a SourceSurface that can provide a DataSourceSurface if required
*/
already_AddRefed<gfx::SourceSurface> WrapSurface(
const RefPtr<gfx::SourceSurface>& aSurface);
/**
* Get DataSourceSurface from the translated equivalent version of aSurface in
* the GPU process.
* @param aSurface the SourceSurface in this process for which we need a
* DataSourceSurface
* @returns a DataSourceSurface created from data for aSurface retrieve from
* GPU process
*/
already_AddRefed<gfx::DataSourceSurface> GetDataSurface(
const gfx::SourceSurface* aSurface);
protected:
void ActorDestroy(ActorDestroyReason aWhy) final;
private:
DISALLOW_COPY_AND_ASSIGN(CanvasChild);
~CanvasChild() final;
static const uint32_t kCacheDataSurfaceThreshold = 10;
static bool mDeactivated;
RefPtr<CanvasDrawEventRecorder> mRecorder;
TextureType mTextureType = TextureType::Unknown;
uint32_t mLastWriteLockCheckpoint = 0;
uint32_t mTransactionsSinceGetDataSurface = kCacheDataSurfaceThreshold;
TimeStamp mLastNonEmptyTransaction = TimeStamp::NowLoRes();
std::vector<RefPtr<gfx::SourceSurface>> mLastTransactionExternalSurfaces;
bool mIsInTransaction = false;
bool mHasOutstandingWriteLock = false;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_layers_CanvasChild_h
|
