Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get rid of references to MemoryDealer in SurfaceFlinger

Browse Source
This commit is contained in:
Mathias Agopian
2009-07-02 18:11:53 -07:00
parent 0926b6184a
commit d763b5d919
12 changed files with 55 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/ui/ISurfaceComposer.h
View File

@@ -92,7 +92,7 @@ public:
virtual sp<ISurfaceFlingerClient> createConnection() = 0;
/* retrieve the control block */
virtual sp<IMemory> getCblk() const = 0;
virtual sp<IMemoryHeap> getCblk() const = 0;
/* open/close transactions. recquires ACCESS_SURFACE_FLINGER permission */
virtual void openGlobalTransaction() = 0;

2
include/ui/ISurfaceFlingerClient.h
View File

@@ -56,7 +56,7 @@ public:
status_t writeToParcel(Parcel* parcel) const;
};
virtual void getControlBlocks(sp<IMemory>* ctl) const = 0;
virtual sp<IMemoryHeap> getControlBlock() const = 0;
virtual sp<ISurface> createSurface( surface_data_t* data,
int pid,

2
include/ui/SurfaceComposerClient.h
View File

@@ -149,7 +149,7 @@ private:
// after assignment
status_t mStatus;
per_client_cblk_t* mControl;
sp<IMemory> mControlMemory;
sp<IMemoryHeap> mControlMemory;
sp<ISurfaceFlingerClient> mClient;
SurfaceFlingerSynchro* mSignalServer;
};

1
libs/surfaceflinger/Layer.h
View File

@@ -42,7 +42,6 @@ namespace android {
class Client;
class LayerBitmap;
class MemoryDealer;
class FreezeLock;
// ---------------------------------------------------------------------------

1
libs/surfaceflinger/LayerBitmap.cpp
View File

@@ -20,7 +20,6 @@
#include <utils/Errors.h>
#include <utils/Log.h>
#include <binder/MemoryDealer.h>
#include <binder/MemoryBase.h>
#include <binder/IMemory.h>

1
libs/surfaceflinger/LayerBitmap.h
View File

@@ -40,7 +40,6 @@ namespace android {
// ---------------------------------------------------------------------------
class IMemory;
class MemoryDealer;
class LayerBitmap;
// ===========================================================================

1
libs/surfaceflinger/LayerBuffer.h
View File

@@ -32,7 +32,6 @@ namespace android {
// ---------------------------------------------------------------------------
class MemoryDealer;
class Region;
class OverlayRef;

54
libs/surfaceflinger/SurfaceFlinger.cpp
View File

@@ -31,8 +31,8 @@
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/MemoryDealer.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <utils/String8.h>
#include <utils/String16.h>
#include <utils/StopWatch.h>
@@ -217,9 +217,9 @@ overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const
return graphicPlane(0).displayHardware().getOverlayEngine();
}
sp<IMemory> SurfaceFlinger::getCblk() const
sp<IMemoryHeap> SurfaceFlinger::getCblk() const
{
return mServerCblkMemory;
return mServerHeap;
}
sp<ISurfaceFlingerClient> SurfaceFlinger::createConnection()
@@ -238,7 +238,7 @@ sp<ISurfaceFlingerClient> SurfaceFlinger::createConnection()
return 0;
}
sp<BClient> bclient =
new BClient(this, token, client->controlBlockMemory());
new BClient(this, token, client->getControlBlockMemory());
return bclient;
}
@@ -301,7 +301,6 @@ void SurfaceFlinger::onFirstRef()
mReadyToRunBarrier.wait();
}
static inline uint16_t pack565(int r, int g, int b) {
return (r<<11)|(g<<5)|b;
}
@@ -311,17 +310,6 @@ status_t SurfaceFlinger::readyToRun()
LOGI( "SurfaceFlinger's main thread ready to run. "
"Initializing graphics H/W...");
// create the shared control-block
mServerHeap = new MemoryDealer(4096, MemoryDealer::READ_ONLY);
LOGE_IF(mServerHeap==0, "can't create shared memory dealer");
mServerCblkMemory = mServerHeap->allocate(4096);
LOGE_IF(mServerCblkMemory==0, "can't create shared control block");
mServerCblk = static_cast<surface_flinger_cblk_t *>(mServerCblkMemory->pointer());
LOGE_IF(mServerCblk==0, "can't get to shared control block's address");
new(mServerCblk) surface_flinger_cblk_t;
// we only support one display currently
int dpy = 0;
@@ -332,6 +320,16 @@ status_t SurfaceFlinger::readyToRun()
plane.setDisplayHardware(hw);
}
// create the shared control-block
mServerHeap = new MemoryHeapBase(4096,
MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap");
LOGE_IF(mServerHeap==0, "can't create shared memory dealer");
mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase());
LOGE_IF(mServerCblk==0, "can't get to shared control block's address");
new(mServerCblk) surface_flinger_cblk_t;
// initialize primary screen
// (other display should be initialized in the same manner, but
// asynchronously, as they could come and go. None of this is supported
@@ -1615,14 +1613,14 @@ Client::Client(ClientID clientID, const sp<SurfaceFlinger>& flinger)
: ctrlblk(0), cid(clientID), mPid(0), mBitmap(0), mFlinger(flinger)
{
const int pgsize = getpagesize();
const int cblksize=((sizeof(per_client_cblk_t)+(pgsize-1))&~(pgsize-1));
mCblkHeap = new MemoryDealer(cblksize);
mCblkMemory = mCblkHeap->allocate(cblksize);
if (mCblkMemory != 0) {
ctrlblk = static_cast<per_client_cblk_t *>(mCblkMemory->pointer());
if (ctrlblk) { // construct the shared structure in-place.
new(ctrlblk) per_client_cblk_t;
}
const int cblksize = ((sizeof(per_client_cblk_t)+(pgsize-1))&~(pgsize-1));
mCblkHeap = new MemoryHeapBase(cblksize, 0,
"SurfaceFlinger Client control-block");
ctrlblk = static_cast<per_client_cblk_t *>(mCblkHeap->getBase());
if (ctrlblk) { // construct the shared structure in-place.
new(ctrlblk) per_client_cblk_t;
}
}
@@ -1685,7 +1683,7 @@ void Client::dump(const char* what)
#pragma mark -
#endif
BClient::BClient(SurfaceFlinger *flinger, ClientID cid, const sp<IMemory>& cblk)
BClient::BClient(SurfaceFlinger *flinger, ClientID cid, const sp<IMemoryHeap>& cblk)
: mId(cid), mFlinger(flinger), mCblk(cblk)
{
}
@@ -1695,8 +1693,8 @@ BClient::~BClient() {
mFlinger->destroyConnection(mId);
}
void BClient::getControlBlocks(sp<IMemory>* ctrl) const {
*ctrl = mCblk;
sp<IMemoryHeap> BClient::getControlBlock() const {
return mCblk;
}
sp<ISurface> BClient::createSurface(

28
libs/surfaceflinger/SurfaceFlinger.h
View File

@@ -27,7 +27,7 @@
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <binder/MemoryDealer.h>
#include <binder/IMemory.h>
#include <binder/Permission.h>
#include <ui/PixelFormat.h>
@@ -76,25 +76,30 @@ public:
inline bool isValid(int32_t i) const;
sp<LayerBaseClient> getLayerUser(int32_t i) const;
const Vector< wp<LayerBaseClient> >& getLayers() const { return mLayers; }
const sp<IMemory>& controlBlockMemory() const { return mCblkMemory; }
void dump(const char* what);
const Vector< wp<LayerBaseClient> >& getLayers() const {
return mLayers;
}
const sp<IMemoryHeap>& getControlBlockMemory() const {
return mCblkHeap;
}
// pointer to this client's control block
per_client_cblk_t* ctrlblk;
ClientID cid;
private:
int getClientPid() const { return mPid; }
int getClientPid() const { return mPid; }
int mPid;
uint32_t mBitmap;
SortedVector<uint8_t> mInUse;
Vector< wp<LayerBaseClient> > mLayers;
sp<MemoryDealer> mCblkHeap;
sp<IMemoryHeap> mCblkHeap;
sp<SurfaceFlinger> mFlinger;
sp<IMemory> mCblkMemory;
};
// ---------------------------------------------------------------------------
@@ -154,7 +159,7 @@ public:
// ISurfaceComposer interface
virtual sp<ISurfaceFlingerClient> createConnection();
virtual sp<IMemory> getCblk() const;
virtual sp<IMemoryHeap> getCblk() const;
virtual void bootFinished();
virtual void openGlobalTransaction();
virtual void closeGlobalTransaction();
@@ -317,8 +322,7 @@ private:
Vector< sp<Client> > mDisconnectedClients;
// constant members (no synchronization needed for access)
sp<MemoryDealer> mServerHeap;
sp<IMemory> mServerCblkMemory;
sp<IMemoryHeap> mServerHeap;
surface_flinger_cblk_t* mServerCblk;
GLuint mWormholeTexName;
nsecs_t mBootTime;
@@ -377,11 +381,11 @@ class BClient : public BnSurfaceFlingerClient
{
public:
BClient(SurfaceFlinger *flinger, ClientID cid,
const sp<IMemory>& cblk);
const sp<IMemoryHeap>& cblk);
~BClient();
// ISurfaceFlingerClient interface
virtual void getControlBlocks(sp<IMemory>* ctrl) const;
virtual sp<IMemoryHeap> getControlBlock() const;
virtual sp<ISurface> createSurface(
surface_data_t* params, int pid,
@@ -394,7 +398,7 @@ public:
private:
ClientID mId;
SurfaceFlinger* mFlinger;
sp<IMemory> mCblk;
sp<IMemoryHeap> mCblk;
};
// ---------------------------------------------------------------------------

4
libs/ui/ISurfaceComposer.cpp
View File

@@ -54,12 +54,12 @@ public:
return interface_cast<ISurfaceFlingerClient>(reply.readStrongBinder());
}
virtual sp<IMemory> getCblk() const
virtual sp<IMemoryHeap> getCblk() const
{
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
remote()->transact(BnSurfaceComposer::GET_CBLK, data, &reply);
return interface_cast<IMemory>(reply.readStrongBinder());
return interface_cast<IMemoryHeap>(reply.readStrongBinder());
}
virtual void openGlobalTransaction()

7
libs/ui/ISurfaceFlingerClient.cpp
View File

@@ -64,12 +64,12 @@ public:
{
}
virtual void getControlBlocks(sp<IMemory>* ctl) const
virtual sp<IMemoryHeap> getControlBlock() const
{
Parcel data, reply;
data.writeInterfaceToken(ISurfaceFlingerClient::getInterfaceDescriptor());
remote()->transact(GET_CBLK, data, &reply);
*ctl = interface_cast<IMemory>(reply.readStrongBinder());
return interface_cast<IMemoryHeap>(reply.readStrongBinder());
}
virtual sp<ISurface> createSurface( surface_data_t* params,
@@ -126,8 +126,7 @@ status_t BnSurfaceFlingerClient::onTransact(
switch(code) {
case GET_CBLK: {
CHECK_INTERFACE(ISurfaceFlingerClient, data, reply);
sp<IMemory> ctl;
getControlBlocks(&ctl);
sp<IMemoryHeap> ctl(getControlBlock());
reply->writeStrongBinder(ctl->asBinder());
return NO_ERROR;
} break;

10
libs/ui/SurfaceComposerClient.cpp
View File

@@ -59,7 +59,7 @@ static Mutex gLock;
static sp<ISurfaceComposer> gSurfaceManager;
static DefaultKeyedVector< sp<IBinder>, sp<SurfaceComposerClient> > gActiveConnections;
static SortedVector<sp<SurfaceComposerClient> > gOpenTransactions;
static sp<IMemory> gServerCblkMemory;
static sp<IMemoryHeap> gServerCblkMemory;
static volatile surface_flinger_cblk_t* gServerCblk;
const sp<ISurfaceComposer>& _get_surface_manager()
@@ -94,7 +94,7 @@ static volatile surface_flinger_cblk_t const * get_cblk()
if (gServerCblk == 0) {
gServerCblkMemory = sm->getCblk();
LOGE_IF(gServerCblkMemory==0, "Can't get server control block");
gServerCblk = (surface_flinger_cblk_t *)gServerCblkMemory->pointer();
gServerCblk = (surface_flinger_cblk_t *)gServerCblkMemory->getBase();
LOGE_IF(gServerCblk==0, "Can't get server control block address");
}
}
@@ -313,9 +313,9 @@ void SurfaceComposerClient::_init(
return;
}
mClient->getControlBlocks(&mControlMemory);
mControlMemory = mClient->getControlBlock();
mSignalServer = new SurfaceFlingerSynchro(sm);
mControl = static_cast<per_client_cblk_t *>(mControlMemory->pointer());
mControl = static_cast<per_client_cblk_t *>(mControlMemory->getBase());
}
SurfaceComposerClient::~SurfaceComposerClient()
@@ -364,7 +364,7 @@ void SurfaceComposerClient::dispose()
{
// this can be called more than once.
sp<IMemory> controlMemory;
sp<IMemoryHeap> controlMemory;
sp<ISurfaceFlingerClient> client;
{