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

Refactor RenderState and remove unused functionality.

Browse Source 
Test: hwui_unit_tests still pass
Change-Id: Ie943671535ab8c5da1bac05985e815e0cb842dc1
This commit is contained in:
Derek Sollenberger
2018-09-20 13:37:24 -04:00
parent 5a5a648b69
commit 28a4d9935c
14 changed files with 22 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libs/hwui/DeferredLayerUpdater.cpp
View File

@@ -29,12 +29,16 @@ DeferredLayerUpdater::DeferredLayerUpdater(RenderState& renderState)
, mGLContextAttached(false)
, mUpdateTexImage(false)
, mLayer(nullptr) {
renderState.registerDeferredLayerUpdater(this);
renderState.registerContextCallback(this);
}
DeferredLayerUpdater::~DeferredLayerUpdater() {
setTransform(nullptr);
mRenderState.unregisterDeferredLayerUpdater(this);
mRenderState.removeContextCallback(this);
destroyLayer();
}
void DeferredLayerUpdater::onContextDestroyed() {
destroyLayer();
}

6
libs/hwui/DeferredLayerUpdater.h
View File

@@ -27,6 +27,7 @@
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include "renderstate/RenderState.h"
#include "surfacetexture/SurfaceTexture.h"
#include "Layer.h"
#include "Rect.h"
@@ -38,7 +39,7 @@ class RenderState;
// Container to hold the properties a layer should be set to at the start
// of a render pass
class DeferredLayerUpdater : public VirtualLightRefBase {
class DeferredLayerUpdater : public VirtualLightRefBase, public IGpuContextCallback {
public:
// Note that DeferredLayerUpdater assumes it is taking ownership of the layer
// and will not call incrementRef on it as a result.
@@ -98,6 +99,9 @@ public:
void destroyLayer();
protected:
void onContextDestroyed() override;
private:
RenderState& mRenderState;

6
libs/hwui/RenderNode.cpp
View File

@@ -158,7 +158,7 @@ void RenderNode::pushLayerUpdate(TreeInfo& info) {
CC_UNLIKELY(properties().getWidth() == 0) || CC_UNLIKELY(properties().getHeight() == 0) ||
CC_UNLIKELY(!properties().fitsOnLayer())) {
if (CC_UNLIKELY(hasLayer())) {
renderthread::CanvasContext::destroyLayer(this);
this->setLayerSurface(nullptr);
}
return;
}
@@ -313,7 +313,7 @@ void RenderNode::deleteDisplayList(TreeObserver& observer, TreeInfo* info) {
void RenderNode::destroyHardwareResources(TreeInfo* info) {
if (hasLayer()) {
renderthread::CanvasContext::destroyLayer(this);
this->setLayerSurface(nullptr);
}
setStagingDisplayList(nullptr);
@@ -323,7 +323,7 @@ void RenderNode::destroyHardwareResources(TreeInfo* info) {
void RenderNode::destroyLayers() {
if (hasLayer()) {
renderthread::CanvasContext::destroyLayer(this);
this->setLayerSurface(nullptr);
}
if (mDisplayList) {
mDisplayList->updateChildren([](RenderNode* child) { child->destroyLayers(); });

2
libs/hwui/hwui/Bitmap.cpp
View File

@@ -230,8 +230,6 @@ Bitmap::~Bitmap() {
mPixelStorage.hardware.buffer = nullptr;
break;
}
android::uirenderer::renderthread::RenderProxy::onBitmapDestroyed(getStableID());
}
bool Bitmap::hasHardwareMipMap() const {

1
libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
View File

@@ -21,6 +21,7 @@
#include "SkiaPipeline.h"
#include "SkiaProfileRenderer.h"
#include "hwui/Bitmap.h"
#include "private/hwui/DrawGlInfo.h"
#include "renderstate/RenderState.h"
#include "renderthread/EglManager.h"
#include "renderthread/Frame.h"

4
libs/hwui/pipeline/skia/SkiaPipeline.cpp
View File

@@ -200,10 +200,6 @@ bool SkiaPipeline::createOrUpdateLayer(RenderNode* node, const DamageAccumulator
return false;
}
void SkiaPipeline::destroyLayer(RenderNode* node) {
node->setLayerSurface(nullptr);
}
void SkiaPipeline::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
GrContext* context = thread.getGrContext();
if (context) {

2
libs/hwui/pipeline/skia/SkiaPipeline.h
View File

@@ -54,8 +54,6 @@ public:
std::vector<VectorDrawableRoot*>* getVectorDrawables() { return &mVectorDrawables; }
static void destroyLayer(RenderNode* node);
static void prepareToDraw(const renderthread::RenderThread& thread, Bitmap* bitmap);
void renderLayersImpl(const LayerUpdateQueue& layers, bool opaque);

76
libs/hwui/renderstate/RenderState.cpp
View File

@@ -14,90 +14,28 @@
* limitations under the License.
*/
#include "renderstate/RenderState.h"
#include <GpuMemoryTracker.h>
#include "DeferredLayerUpdater.h"
#include "Snapshot.h"
#include "renderthread/CanvasContext.h"
#include "renderthread/EglManager.h"
#include "utils/GLUtils.h"
#include <algorithm>
#include <ui/ColorSpace.h>
#include "renderthread/RenderThread.h"
#include "GpuMemoryTracker.h"
namespace android {
namespace uirenderer {
RenderState::RenderState(renderthread::RenderThread& thread)
: mRenderThread(thread), mViewportWidth(0), mViewportHeight(0), mFramebuffer(0) {
RenderState::RenderState(renderthread::RenderThread& thread) : mRenderThread(thread) {
mThreadId = pthread_self();
}
RenderState::~RenderState() {
}
void RenderState::onContextCreated() {
GpuMemoryTracker::onGpuContextCreated();
}
static void destroyLayerInUpdater(DeferredLayerUpdater* layerUpdater) {
layerUpdater->destroyLayer();
}
void RenderState::onContextDestroyed() {
std::for_each(mActiveLayerUpdaters.begin(), mActiveLayerUpdaters.end(), destroyLayerInUpdater);
for(auto callback : mContextCallbacks) {
callback->onContextDestroyed();
}
GpuMemoryTracker::onGpuContextDestroyed();
}
GrContext* RenderState::getGrContext() const {
return mRenderThread.getGrContext();
}
void RenderState::onBitmapDestroyed(uint32_t pixelRefId) {
// DEAD CODE
}
void RenderState::setViewport(GLsizei width, GLsizei height) {
mViewportWidth = width;
mViewportHeight = height;
glViewport(0, 0, mViewportWidth, mViewportHeight);
}
void RenderState::getViewport(GLsizei* outWidth, GLsizei* outHeight) {
*outWidth = mViewportWidth;
*outHeight = mViewportHeight;
}
void RenderState::bindFramebuffer(GLuint fbo) {
if (mFramebuffer != fbo) {
mFramebuffer = fbo;
glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
}
}
GLuint RenderState::createFramebuffer() {
GLuint ret;
glGenFramebuffers(1, &ret);
return ret;
}
void RenderState::deleteFramebuffer(GLuint fbo) {
if (mFramebuffer == fbo) {
// GL defines that deleting the currently bound FBO rebinds FBO 0.
// Reflect this in our cached value.
mFramebuffer = 0;
}
glDeleteFramebuffers(1, &fbo);
}
void RenderState::debugOverdraw(bool enable, bool clear) {
// DEAD CODE
}
void RenderState::postDecStrong(VirtualLightRefBase* object) {
if (pthread_equal(mThreadId, pthread_self())) {
object->decStrong(nullptr);
@@ -110,13 +48,5 @@ void RenderState::postDecStrong(VirtualLightRefBase* object) {
// Render
///////////////////////////////////////////////////////////////////////////////
void RenderState::dump() {
// DEAD CODE
}
renderthread::RenderThread& RenderState::getRenderThread() {
return mRenderThread;
}
} /* namespace uirenderer */
} /* namespace android */

55
libs/hwui/renderstate/RenderState.h
View File

@@ -18,26 +18,16 @@
#include "utils/Macros.h"
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <private/hwui/DrawGlInfo.h>
#include <ui/Region.h>
#include <utils/Functor.h>
#include <utils/Mutex.h>
#include <utils/RefBase.h>
#include <set>
class GrContext;
namespace android {
namespace uirenderer {
class Layer;
class DeferredLayerUpdater;
namespace renderthread {
class CacheManager;
class CanvasContext;
class RenderThread;
}
@@ -55,69 +45,30 @@ class RenderState {
friend class renderthread::CacheManager;
public:
void onBitmapDestroyed(uint32_t pixelRefId);
void setViewport(GLsizei width, GLsizei height);
void getViewport(GLsizei* outWidth, GLsizei* outHeight);
void bindFramebuffer(GLuint fbo);
GLuint getFramebuffer() { return mFramebuffer; }
GLuint createFramebuffer();
void deleteFramebuffer(GLuint fbo);
void debugOverdraw(bool enable, bool clear);
void registerContextCallback(IGpuContextCallback* cb) { mContextCallbacks.insert(cb); }
void removeContextCallback(IGpuContextCallback* cb) { mContextCallbacks.erase(cb); }
void registerLayer(Layer* layer) { mActiveLayers.insert(layer); }
void unregisterLayer(Layer* layer) { mActiveLayers.erase(layer); }
void registerCanvasContext(renderthread::CanvasContext* context) {
mRegisteredContexts.insert(context);
}
void unregisterCanvasContext(renderthread::CanvasContext* context) {
mRegisteredContexts.erase(context);
}
void registerDeferredLayerUpdater(DeferredLayerUpdater* layerUpdater) {
mActiveLayerUpdaters.insert(layerUpdater);
}
void unregisterDeferredLayerUpdater(DeferredLayerUpdater* layerUpdater) {
mActiveLayerUpdaters.erase(layerUpdater);
}
// TODO: This system is a little clunky feeling, this could use some
// more thinking...
void postDecStrong(VirtualLightRefBase* object);
GrContext* getGrContext() const;
void dump();
renderthread::RenderThread& getRenderThread();
renderthread::RenderThread& getRenderThread() const { return mRenderThread; }
private:
explicit RenderState(renderthread::RenderThread& thread);
~RenderState();
~RenderState() {}
// Context notifications are only to be triggered by renderthread::RenderThread
void onContextCreated();
void onContextDestroyed();
renderthread::RenderThread& mRenderThread;
std::set<IGpuContextCallback*> mContextCallbacks;
std::set<Layer*> mActiveLayers;
std::set<DeferredLayerUpdater*> mActiveLayerUpdaters;
std::set<renderthread::CanvasContext*> mRegisteredContexts;
GLsizei mViewportWidth;
GLsizei mViewportHeight;
GLuint mFramebuffer;
renderthread::RenderThread& mRenderThread;
pthread_t mThreadId;
};

7
libs/hwui/renderthread/CanvasContext.cpp
View File

@@ -27,7 +27,6 @@
#include "pipeline/skia/SkiaOpenGLPipeline.h"
#include "pipeline/skia/SkiaPipeline.h"
#include "pipeline/skia/SkiaVulkanPipeline.h"
#include "renderstate/RenderState.h"
#include "utils/GLUtils.h"
#include "utils/TimeUtils.h"
#include "../Properties.h"
@@ -76,10 +75,6 @@ CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
return nullptr;
}
void CanvasContext::destroyLayer(RenderNode* node) {
skiapipeline::SkiaPipeline::destroyLayer(node);
}
void CanvasContext::invokeFunctor(const RenderThread& thread, Functor* functor) {
ATRACE_CALL();
auto renderType = Properties::getRenderPipelineType();
@@ -113,13 +108,11 @@ CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode*
, mRenderPipeline(std::move(renderPipeline)) {
rootRenderNode->makeRoot();
mRenderNodes.emplace_back(rootRenderNode);
mRenderThread.renderState().registerCanvasContext(this);
mProfiler.setDensity(mRenderThread.mainDisplayInfo().density);
}
CanvasContext::~CanvasContext() {
destroy();
mRenderThread.renderState().unregisterCanvasContext(this);
for (auto& node : mRenderNodes) {
node->clearRoot();
}

6
libs/hwui/renderthread/CanvasContext.h
View File

@@ -96,12 +96,6 @@ public:
*/
void unpinImages() { mRenderPipeline->unpinImages(); }
/**
* Destroy any layers that have been attached to the provided RenderNode removing
* any state that may have been set during createOrUpdateLayer().
*/
static void destroyLayer(RenderNode* node);
static void invokeFunctor(const RenderThread& thread, Functor* functor);
static void prepareToDraw(const RenderThread& thread, Bitmap* bitmap);

7
libs/hwui/renderthread/RenderProxy.cpp
View File

@@ -345,13 +345,6 @@ int RenderProxy::copyHWBitmapInto(Bitmap* hwBitmap, SkBitmap* bitmap) {
}
}
void RenderProxy::onBitmapDestroyed(uint32_t pixelRefId) {
if (!RenderThread::hasInstance()) return;
RenderThread& thread = RenderThread::getInstance();
thread.queue().post(
[&thread, pixelRefId]() { thread.renderState().onBitmapDestroyed(pixelRefId); });
}
void RenderProxy::disableVsync() {
Properties::disableVsync = true;
}

2
libs/hwui/renderthread/RenderProxy.h
View File

@@ -127,8 +127,6 @@ public:
static int copyHWBitmapInto(Bitmap* hwBitmap, SkBitmap* bitmap);
static void onBitmapDestroyed(uint32_t pixelRefId);
ANDROID_API static void disableVsync();
static void repackVectorDrawableAtlas();

1
libs/hwui/tests/common/TestUtils.h
View File

@@ -24,6 +24,7 @@
#include <Snapshot.h>
#include <hwui/Bitmap.h>
#include <pipeline/skia/SkiaRecordingCanvas.h>
#include <private/hwui/DrawGlInfo.h>
#include <renderstate/RenderState.h>
#include <renderthread/RenderThread.h>