/usr/include/thunderbird/mozilla/layers/ImageBridgeParent.h is in thunderbird-dev 1:52.8.0-1~deb8u1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 153 154 155 | /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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/. */
#ifndef gfx_layers_ipc_ImageBridgeParent_h_
#define gfx_layers_ipc_ImageBridgeParent_h_
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint64_t
#include "CompositableTransactionParent.h"
#include "ImageContainerParent.h"
#include "mozilla/Assertions.h" // for MOZ_ASSERT_HELPER2
#include "mozilla/Attributes.h" // for override
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/SharedMemory.h" // for SharedMemory, etc
#include "mozilla/layers/CompositorThread.h"
#include "mozilla/layers/PImageBridgeParent.h"
#include "nsISupportsImpl.h"
#include "nsTArrayForwardDeclare.h" // for InfallibleTArray
class MessageLoop;
namespace base {
class Thread;
} // namespace base
namespace mozilla {
namespace ipc {
class Shmem;
} // namespace ipc
namespace layers {
/**
* ImageBridgeParent is the manager Protocol of ImageContainerParent.
* It's purpose is mainly to setup the IPDL connection. Most of the
* interesting stuff is in ImageContainerParent.
*/
class ImageBridgeParent final : public PImageBridgeParent,
public CompositableParentManager,
public ShmemAllocator
{
public:
typedef InfallibleTArray<CompositableOperation> EditArray;
typedef InfallibleTArray<OpDestroy> OpDestroyArray;
typedef InfallibleTArray<EditReply> EditReplyArray;
protected:
ImageBridgeParent(MessageLoop* aLoop, ProcessId aChildProcessId);
public:
~ImageBridgeParent();
/**
* Creates the globals of ImageBridgeParent.
*/
static void Setup();
static ImageBridgeParent* CreateSameProcess();
static bool CreateForGPUProcess(Endpoint<PImageBridgeParent>&& aEndpoint);
static bool CreateForContent(Endpoint<PImageBridgeParent>&& aEndpoint);
virtual ShmemAllocator* AsShmemAllocator() override { return this; }
virtual void ActorDestroy(ActorDestroyReason aWhy) override;
// CompositableParentManager
virtual void SendAsyncMessage(const InfallibleTArray<AsyncParentMessageData>& aMessage) override;
virtual void NotifyNotUsed(PTextureParent* aTexture, uint64_t aTransactionId) override;
virtual base::ProcessId GetChildProcessId() override
{
return OtherPid();
}
// PImageBridge
virtual bool RecvImageBridgeThreadId(const PlatformThreadId& aThreadId) override;
virtual bool RecvUpdate(EditArray&& aEdits, OpDestroyArray&& aToDestroy,
const uint64_t& aFwdTransactionId,
EditReplyArray* aReply) override;
virtual bool RecvUpdateNoSwap(EditArray&& aEdits, OpDestroyArray&& aToDestroy,
const uint64_t& aFwdTransactionId) override;
PCompositableParent* AllocPCompositableParent(const TextureInfo& aInfo,
PImageContainerParent* aImageContainer,
uint64_t*) override;
bool DeallocPCompositableParent(PCompositableParent* aActor) override;
virtual PTextureParent* AllocPTextureParent(const SurfaceDescriptor& aSharedData,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
const uint64_t& aSerial) override;
virtual bool DeallocPTextureParent(PTextureParent* actor) override;
PMediaSystemResourceManagerParent* AllocPMediaSystemResourceManagerParent() override;
bool DeallocPMediaSystemResourceManagerParent(PMediaSystemResourceManagerParent* aActor) override;
virtual PImageContainerParent* AllocPImageContainerParent() override;
virtual bool DeallocPImageContainerParent(PImageContainerParent* actor) override;
// Shutdown step 1
virtual bool RecvWillClose() override;
MessageLoop* GetMessageLoop() const { return mMessageLoop; }
// ShmemAllocator
virtual bool AllocShmem(size_t aSize,
ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem) override;
virtual bool AllocUnsafeShmem(size_t aSize,
ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem) override;
virtual void DeallocShmem(ipc::Shmem& aShmem) override;
virtual bool IsSameProcess() const override;
static RefPtr<ImageBridgeParent> GetInstance(ProcessId aId);
static bool NotifyImageComposites(nsTArray<ImageCompositeNotification>& aNotifications);
virtual bool UsesImageBridge() const override { return true; }
virtual bool IPCOpen() const override { return !mClosed; }
protected:
void OnChannelConnected(int32_t pid) override;
void Bind(Endpoint<PImageBridgeParent>&& aEndpoint);
private:
void DeferredDestroy();
MessageLoop* mMessageLoop;
// This keeps us alive until ActorDestroy(), at which point we do a
// deferred destruction of ourselves.
RefPtr<ImageBridgeParent> mSelfRef;
bool mSetChildThreadPriority;
bool mClosed;
/**
* Map of all living ImageBridgeParent instances
*/
static std::map<base::ProcessId, ImageBridgeParent*> sImageBridges;
RefPtr<CompositorThreadHolder> mCompositorThreadHolder;
};
} // namespace layers
} // namespace mozilla
#endif // gfx_layers_ipc_ImageBridgeParent_h_
|