1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 : #ifndef PCompositorChild_h
7 : #define PCompositorChild_h
8 :
9 : #include "mozilla/layers/PCompositor.h"
10 : namespace mozilla {
11 : namespace layers {
12 : class PLayersChild;
13 : } // namespace layers
14 : } // namespace mozilla
15 :
16 : #ifdef DEBUG
17 : #include "prenv.h"
18 : #endif // DEBUG
19 : #include "base/id_map.h"
20 : #include "mozilla/ipc/RPCChannel.h"
21 :
22 :
23 : namespace mozilla {
24 : namespace layers {
25 : class PLayersChild;
26 : } // namespace layers
27 : } // namespace mozilla
28 :
29 : namespace mozilla {
30 : namespace layers {
31 :
32 :
33 : class /*NS_ABSTRACT_CLASS*/ PCompositorChild :
34 : protected mozilla::ipc::RPCChannel::RPCListener,
35 : protected mozilla::ipc::IProtocolManager<mozilla::ipc::RPCChannel::RPCListener>
36 : {
37 : friend class mozilla::layers::PLayersChild;
38 :
39 : protected:
40 : typedef mozilla::ipc::ActorHandle ActorHandle;
41 : typedef mozilla::ipc::Shmem Shmem;
42 : typedef mozilla::LayersBackend LayersBackend;
43 : typedef mozilla::null_t null_t;
44 : typedef mozilla::layers::PLayersChild PLayersChild;
45 : typedef base::ProcessId ProcessId;
46 : typedef mozilla::ipc::ProtocolId ProtocolId;
47 : typedef mozilla::ipc::Transport Transport;
48 : typedef mozilla::ipc::TransportDescriptor TransportDescriptor;
49 :
50 : typedef PCompositor::State State;
51 :
52 : virtual PLayersChild*
53 : AllocPLayers(const LayersBackend& backend) = 0;
54 : virtual bool
55 : DeallocPLayers(PLayersChild* actor) = 0;
56 :
57 : virtual void
58 : ActorDestroy(ActorDestroyReason why);
59 :
60 : virtual void
61 : ProcessingError(Result code);
62 : virtual bool
63 : ShouldContinueFromReplyTimeout();
64 : virtual void
65 : EnteredCxxStack();
66 : virtual void
67 : ExitedCxxStack();
68 : virtual void
69 : EnteredCall();
70 : virtual void
71 : ExitedCall();
72 :
73 : public:
74 : typedef IPC::Message Message;
75 : typedef mozilla::ipc::RPCChannel Channel;
76 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
77 : typedef base::ProcessHandle ProcessHandle;
78 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
79 : typedef mozilla::ipc::SharedMemory SharedMemory;
80 : typedef mozilla::ipc::Trigger Trigger;
81 :
82 : public:
83 : PCompositorChild();
84 :
85 : virtual ~PCompositorChild();
86 :
87 : bool
88 : Open(
89 : Channel::Transport* aTransport,
90 : ProcessHandle aOtherProcess,
91 : MessageLoop* aThread = 0,
92 : AsyncChannel::Side aSide = Channel::Unknown);
93 :
94 : bool
95 : Open(
96 : AsyncChannel* aChannel,
97 : MessageLoop* aMessageLoop,
98 : AsyncChannel::Side aSide = Channel::Unknown);
99 :
100 : void
101 : Close();
102 :
103 : void
104 : SetReplyTimeoutMs(int32 aTimeoutMs);
105 :
106 : void
107 : ManagedPLayersChild(InfallibleTArray<PLayersChild*>& aArr) const;
108 : const InfallibleTArray<PLayersChild*>&
109 : ManagedPLayersChild() const;
110 :
111 : PCompositor::State
112 : state();
113 :
114 : bool
115 : SendStop();
116 :
117 : PLayersChild*
118 : SendPLayersConstructor(const LayersBackend& backend);
119 :
120 : PLayersChild*
121 : SendPLayersConstructor(
122 : PLayersChild* actor,
123 : const LayersBackend& backend);
124 :
125 : virtual int32
126 : Register(ChannelListener* aRouted);
127 : virtual int32
128 : RegisterID(
129 : ChannelListener* aRouted,
130 : int32 aId);
131 : virtual ChannelListener*
132 : Lookup(int32 aId);
133 : virtual void
134 : Unregister(int32 aId);
135 : virtual void
136 : RemoveManagee(
137 : int32 aProtocolId,
138 : ChannelListener* aListener);
139 : virtual Shmem::SharedMemory*
140 : CreateSharedMemory(
141 : size_t aSize,
142 : Shmem::SharedMemory::SharedMemoryType type,
143 : bool unsafe,
144 : Shmem::id_t* aId);
145 : virtual bool
146 : AdoptSharedMemory(
147 : Shmem::SharedMemory* segment,
148 : Shmem::id_t* aId);
149 : virtual Shmem::SharedMemory*
150 : LookupSharedMemory(Shmem::id_t aId);
151 : virtual bool
152 : IsTrackingSharedMemory(Shmem::SharedMemory* segment);
153 : virtual bool
154 : DestroySharedMemory(Shmem& aShmem);
155 : virtual ProcessHandle
156 : OtherProcess() const;
157 : virtual AsyncChannel*
158 : GetIPCChannel();
159 :
160 : virtual Result
161 : OnMessageReceived(const Message& __msg);
162 :
163 : virtual Result
164 : OnMessageReceived(
165 : const Message& __msg,
166 : Message*& __reply);
167 :
168 : virtual Result
169 : OnCallReceived(
170 : const Message& __msg,
171 : Message*& __reply);
172 :
173 : void
174 : OnProcessingError(Result code);
175 :
176 : bool
177 : OnReplyTimeout();
178 :
179 : void
180 : OnEnteredCxxStack();
181 : void
182 : OnExitedCxxStack();
183 : void
184 : OnEnteredCall();
185 : void
186 : OnExitedCall();
187 : bool
188 : IsOnCxxStack() const;
189 : void
190 : FlushPendingRPCQueue();
191 :
192 : void
193 : OnChannelClose();
194 :
195 : void
196 : OnChannelError();
197 :
198 : void
199 : OnChannelConnected(int32 pid);
200 :
201 : // Methods for managing shmem
202 : bool
203 : AllocShmem(
204 : size_t aSize,
205 : Shmem::SharedMemory::SharedMemoryType aType,
206 : Shmem* aMem);
207 :
208 : bool
209 : AllocUnsafeShmem(
210 : size_t aSize,
211 : Shmem::SharedMemory::SharedMemoryType aType,
212 : Shmem* aMem);
213 :
214 : bool
215 : AdoptShmem(
216 : Shmem& aMem,
217 : Shmem* aOutMem);
218 :
219 : bool
220 : DeallocShmem(Shmem& aMem);
221 :
222 : void
223 : ProcessNativeEventsInRPCCall();
224 :
225 : private:
226 : virtual void
227 : FatalError(const char* const msg) const;
228 :
229 : void
230 : DestroySubtree(ActorDestroyReason why);
231 :
232 : void
233 : DeallocSubtree();
234 :
235 : void
236 : DeallocShmems();
237 :
238 : template<typename T>
239 : void
240 0 : Write(
241 : const T& __v,
242 : Message* __msg)
243 : {
244 0 : IPC::WriteParam(__msg, __v);
245 0 : }
246 :
247 : template<typename T>
248 : bool
249 0 : Read(
250 : T* __v,
251 : const Message* __msg,
252 : void** __iter)
253 : {
254 0 : return IPC::ReadParam(__msg, __iter, __v);
255 : }
256 :
257 : void
258 : Write(
259 : PLayersChild* __v,
260 : Message* __msg,
261 : bool __nullable);
262 :
263 : bool
264 : Read(
265 : PLayersChild** __v,
266 : const Message* __msg,
267 : void** __iter,
268 : bool __nullable) NS_WARN_UNUSED_RESULT;
269 :
270 : Channel mChannel;
271 : IDMap<ChannelListener> mActorMap;
272 : int32 mLastRouteId;
273 : ProcessHandle mOtherProcess;
274 : IDMap<Shmem::SharedMemory> mShmemMap;
275 : Shmem::id_t mLastShmemId;
276 : State mState;
277 : // Sorted by pointer value
278 : InfallibleTArray<PLayersChild*> mManagedPLayersChild;
279 : };
280 :
281 :
282 : } // namespace layers
283 : } // namespace mozilla
284 :
285 : #if 0
286 :
287 : //-----------------------------------------------------------------------------
288 : // Skeleton implementation of abstract actor class
289 :
290 : // Header file contents
291 : namespace mozilla {
292 : namespace layers {
293 : class CompositorChild :
294 : public PCompositorChild
295 : {
296 : virtual PLayersChild*
297 : AllocPLayers(const LayersBackend& backend);
298 :
299 : virtual bool
300 : DeallocPLayers(PLayersChild* actor);
301 :
302 : CompositorChild();
303 : virtual ~CompositorChild();
304 : };
305 : } // namespace layers
306 : } // namespace mozilla
307 :
308 :
309 : // C++ file contents
310 : namespace mozilla {
311 : namespace layers {
312 : PLayersChild*
313 : CompositorChild::AllocPLayers(const LayersBackend& backend)
314 : {
315 : return 0;
316 : }
317 :
318 : bool
319 : CompositorChild::DeallocPLayers(PLayersChild* actor)
320 : {
321 : return false;
322 : }
323 :
324 : CompositorChild::CompositorChild()
325 : {
326 : MOZ_COUNT_CTOR(CompositorChild);
327 : }
328 :
329 : CompositorChild::~CompositorChild()
330 : {
331 : MOZ_COUNT_DTOR(CompositorChild);
332 : }
333 :
334 : } // namespace layers
335 : } // namespace mozilla
336 : #endif // if 0
337 :
338 : #endif // ifndef PCompositorChild_h
|