blob: 389546ea7973ae31d938480266b9bcb52dfed3dd [file] [log] [blame]
John Reck23b797a2014-01-03 18:08:34 -08001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Chris Craik5e00c7c2016-07-06 16:10:09 -070017#pragma once
John Reck23b797a2014-01-03 18:08:34 -080018
John Reckba6adf62015-02-19 14:36:50 -080019#include "DamageAccumulator.h"
John Reckba6adf62015-02-19 14:36:50 -080020#include "FrameInfo.h"
John Reck4c9e59d2015-05-12 07:17:50 -070021#include "FrameInfoVisualizer.h"
Andres Morales910beb82016-02-02 16:19:40 -080022#include "FrameMetricsReporter.h"
Chris Craik0b7e8242015-10-28 16:50:44 -070023#include "IContextFactory.h"
Stan Iliev768e3932016-07-08 21:34:52 -040024#include "IRenderPipeline.h"
Fedor Kudasov85d6f102019-07-31 15:58:16 +010025#include "JankTracker.h"
Chris Craik0b7e8242015-10-28 16:50:44 -070026#include "LayerUpdateQueue.h"
John Reck0fa0cbc2019-04-05 16:57:46 -070027#include "Lighting.h"
John Reck848f6512018-12-03 13:26:43 -080028#include "ReliableSurface.h"
John Reck0fa0cbc2019-04-05 16:57:46 -070029#include "RenderNode.h"
John Reckba6adf62015-02-19 14:36:50 -080030#include "renderthread/RenderTask.h"
31#include "renderthread/RenderThread.h"
Stan Iliev7203e1f2019-07-25 13:12:02 -040032#include "utils/RingBuffer.h"
John Reckb36bfdd2020-07-23 13:47:49 -070033#include "ColorMode.h"
John Reck998a6d82014-08-28 15:35:53 -070034
John Reck19b6bcf2014-02-14 20:03:38 -080035#include <SkBitmap.h>
John Reckd04794a2015-05-08 10:04:36 -070036#include <SkRect.h>
Leon Scroggins III6c5864c2019-04-03 15:09:25 -040037#include <SkSize.h>
John Reck1bcacfd2017-11-03 10:12:19 -070038#include <cutils/compiler.h>
John Reck1bcacfd2017-11-03 10:12:19 -070039#include <utils/Functor.h>
Jorim Jaggi71db8892021-02-03 23:19:29 +010040#include <utils/Mutex.h>
John Reck4f02bf42014-01-03 18:09:17 -080041
John Reck38f6c032016-03-17 10:23:49 -070042#include <functional>
John Reck0fa0cbc2019-04-05 16:57:46 -070043#include <future>
John Reckba6adf62015-02-19 14:36:50 -080044#include <set>
John Reckb36016c2015-03-11 08:50:53 -070045#include <string>
Stan Iliev7203e1f2019-07-25 13:12:02 -040046#include <utility>
Skuhneea7a7fb2015-08-28 07:10:31 -070047#include <vector>
John Reck23b797a2014-01-03 18:08:34 -080048
49namespace android {
50namespace uirenderer {
John Reck4f02bf42014-01-03 18:09:17 -080051
John Reck119907c2014-08-14 09:02:01 -070052class AnimationContext;
John Reck19b6bcf2014-02-14 20:03:38 -080053class DeferredLayerUpdater;
Stan Iliev216b1572018-03-26 14:29:50 -040054class ErrorHandler;
John Reck1949e792014-04-08 15:18:56 -070055class Layer;
Chris Craik5e00c7c2016-07-06 16:10:09 -070056class Rect;
John Reck443a7142014-09-04 17:40:05 -070057class RenderState;
John Reck4f02bf42014-01-03 18:09:17 -080058
John Reck23b797a2014-01-03 18:08:34 -080059namespace renderthread {
60
Stan Iliev768e3932016-07-08 21:34:52 -040061class Frame;
John Reck1125d1f2014-10-23 11:02:19 -070062
John Reck23b797a2014-01-03 18:08:34 -080063// This per-renderer class manages the bridge between the global EGL context
64// and the render surface.
John Reck119907c2014-08-14 09:02:01 -070065// TODO: Rename to Renderer or some other per-window, top-level manager
John Recke45b1fd2014-04-15 09:50:16 -070066class CanvasContext : public IFrameCallback {
John Reck23b797a2014-01-03 18:08:34 -080067public:
John Reck1bcacfd2017-11-03 10:12:19 -070068 static CanvasContext* create(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
69 IContextFactory* contextFactory);
John Recke45b1fd2014-04-15 09:50:16 -070070 virtual ~CanvasContext();
John Reck23b797a2014-01-03 18:08:34 -080071
Derek Sollenberger6a21ca52016-09-28 13:39:55 -040072 /**
73 * Update or create a layer specific for the provided RenderNode. The layer
74 * attached to the node will be specific to the RenderPipeline used by this
75 * context
76 *
77 * @return true if the layer has been created or updated
78 */
Stan Iliev216b1572018-03-26 14:29:50 -040079 bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& dmgAccumulator,
80 ErrorHandler* errorHandler) {
Peiyong Lin1f6aa122018-09-10 16:28:08 -070081 return mRenderPipeline->createOrUpdateLayer(node, dmgAccumulator, errorHandler);
Derek Sollenberger6a21ca52016-09-28 13:39:55 -040082 }
83
84 /**
Derek Sollenbergerb7d34b62016-11-04 10:46:18 -040085 * Pin any mutable images to the GPU cache. A pinned images is guaranteed to
86 * remain in the cache until it has been unpinned. We leverage this feature
87 * to avoid making a CPU copy of the pixels.
88 *
Derek Sollenberger189e8742016-11-16 16:00:17 -050089 * @return true if all images have been successfully pinned to the GPU cache
Derek Sollenbergerb7d34b62016-11-04 10:46:18 -040090 * and false otherwise (e.g. cache limits have been exceeded).
91 */
92 bool pinImages(std::vector<SkImage*>& mutableImages) {
93 return mRenderPipeline->pinImages(mutableImages);
94 }
John Reck1bcacfd2017-11-03 10:12:19 -070095 bool pinImages(LsaVector<sk_sp<Bitmap>>& images) { return mRenderPipeline->pinImages(images); }
Derek Sollenbergerb7d34b62016-11-04 10:46:18 -040096
97 /**
98 * Unpin any image that had be previously pinned to the GPU cache
99 */
100 void unpinImages() { mRenderPipeline->unpinImages(); }
101
Derek Sollenbergerdaf72292016-10-25 12:09:18 -0400102 static void invokeFunctor(const RenderThread& thread, Functor* functor);
103
104 static void prepareToDraw(const RenderThread& thread, Bitmap* bitmap);
105
Derek Sollenberger0df62092016-09-27 16:04:42 -0400106 /*
107 * If Properties::isSkiaEnabled() is true then this will return the Skia
108 * grContext associated with the current RenderPipeline.
109 */
Adlai Hollerab762152020-09-16 10:37:19 -0400110 GrDirectContext* getGrContext() const { return mRenderThread.getGrContext(); }
Derek Sollenberger0df62092016-09-27 16:04:42 -0400111
Huihong Luo054b8d32021-02-24 18:48:12 -0800112 ASurfaceControl* getSurfaceControl() const { return mSurfaceControl; }
Huihong Luo540fdf82021-06-25 13:59:39 -0700113 int32_t getSurfaceControlGenerationId() const { return mSurfaceControlGenerationId; }
Huihong Luo054b8d32021-02-24 18:48:12 -0800114
John Reck1125d1f2014-10-23 11:02:19 -0700115 // Won't take effect until next EGLSurface creation
116 void setSwapBehavior(SwapBehavior swapBehavior);
117
Alec Mouri43fe6fc2019-12-23 07:46:19 -0800118 void setSurface(ANativeWindow* window, bool enableTimeout = true);
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800119 void setSurfaceControl(ASurfaceControl* surfaceControl);
John Reckf8441e62017-10-23 13:10:41 -0700120 bool pauseSurface();
John Reck8afcc762016-04-13 10:24:06 -0700121 void setStopped(bool stopped);
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400122 bool hasSurface() const { return mNativeSurface.get(); }
John Reck8785ceb2018-10-29 16:45:58 -0700123 void allocateBuffers();
John Reckaa95a882014-11-07 11:02:07 -0800124
John Reck8785ceb2018-10-29 16:45:58 -0700125 void setLightAlpha(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
126 void setLightGeometry(const Vector3& lightCenter, float lightRadius);
John Reck63a06672014-05-07 13:45:54 -0700127 void setOpaque(bool opaque);
John Reckb36bfdd2020-07-23 13:47:49 -0700128 void setColorMode(ColorMode mode);
John Reck8afcc762016-04-13 10:24:06 -0700129 bool makeCurrent();
John Reck1bcacfd2017-11-03 10:12:19 -0700130 void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued, RenderNode* target);
Bo Liu4d0f1f12021-05-06 16:49:40 -0400131 // Returns the DequeueBufferDuration.
132 nsecs_t draw();
John Reck2de950d2017-01-25 10:58:30 -0800133 void destroy();
John Reck23b797a2014-01-03 18:08:34 -0800134
Chris Craik0b7e8242015-10-28 16:50:44 -0700135 // IFrameCallback, Choreographer-driven frame callback entry point
Chris Craikd41c4d82015-01-05 15:51:13 -0800136 virtual void doFrame() override;
Skuhneea7a7fb2015-08-28 07:10:31 -0700137 void prepareAndDraw(RenderNode* node);
John Recke45b1fd2014-04-15 09:50:16 -0700138
John Reck2de950d2017-01-25 10:58:30 -0800139 void buildLayer(RenderNode* node);
John Reck998a6d82014-08-28 15:35:53 -0700140 void markLayerInUse(RenderNode* node);
John Reck19b6bcf2014-02-14 20:03:38 -0800141
John Reck2de950d2017-01-25 10:58:30 -0800142 void destroyHardwareResources();
John Reckf47a5942014-06-30 16:20:04 -0700143 static void trimMemory(RenderThread& thread, int level);
John Recke1628b72014-05-23 15:11:19 -0700144
Derek Sollenberger56ad6ec2016-07-22 12:13:32 -0400145 DeferredLayerUpdater* createTextureLayer();
John Reck1949e792014-04-08 15:18:56 -0700146
John Reckf47a5942014-06-30 16:20:04 -0700147 void stopDrawing();
John Recka5dda642014-05-22 15:43:54 -0700148 void notifyFramePending();
149
John Reck4c9e59d2015-05-12 07:17:50 -0700150 FrameInfoVisualizer& profiler() { return mProfiler; }
John Reckfe5e7b72014-05-23 17:42:28 -0700151
John Reckba6adf62015-02-19 14:36:50 -0800152 void dumpFrames(int fd);
153 void resetFrameStats();
154
John Reckdf1742e2017-01-19 15:56:21 -0800155 void setName(const std::string&& name);
John Reckb36016c2015-03-11 08:50:53 -0700156
John Reck2de950d2017-01-25 10:58:30 -0800157 void addRenderNode(RenderNode* node, bool placeFront);
158 void removeRenderNode(RenderNode* node);
Skuhneea7a7fb2015-08-28 07:10:31 -0700159
John Reck1bcacfd2017-11-03 10:12:19 -0700160 void setContentDrawBounds(const Rect& bounds) { mContentDrawBounds = bounds; }
Skuhneea7a7fb2015-08-28 07:10:31 -0700161
Andres Morales910beb82016-02-02 16:19:40 -0800162 void addFrameMetricsObserver(FrameMetricsObserver* observer) {
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000163 std::scoped_lock lock(mFrameMetricsReporterMutex);
Andres Morales910beb82016-02-02 16:19:40 -0800164 if (mFrameMetricsReporter.get() == nullptr) {
165 mFrameMetricsReporter.reset(new FrameMetricsReporter());
Andres Morales06f5bc72015-12-15 15:21:31 -0800166 }
167
Andres Morales910beb82016-02-02 16:19:40 -0800168 mFrameMetricsReporter->addObserver(observer);
Andres Morales06f5bc72015-12-15 15:21:31 -0800169 }
170
Andres Morales910beb82016-02-02 16:19:40 -0800171 void removeFrameMetricsObserver(FrameMetricsObserver* observer) {
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000172 std::scoped_lock lock(mFrameMetricsReporterMutex);
Andres Morales910beb82016-02-02 16:19:40 -0800173 if (mFrameMetricsReporter.get() != nullptr) {
174 mFrameMetricsReporter->removeObserver(observer);
175 if (!mFrameMetricsReporter->hasObservers()) {
176 mFrameMetricsReporter.reset(nullptr);
Andres Morales06f5bc72015-12-15 15:21:31 -0800177 }
178 }
179 }
180
John Reck38f6c032016-03-17 10:23:49 -0700181 // Used to queue up work that needs to be completed before this frame completes
Derek Sollenberger3fedf5a2020-02-21 13:07:28 -0500182 void enqueueFrameWork(std::function<void()>&& func);
John Reck38f6c032016-03-17 10:23:49 -0700183
Derek Sollenberger3fedf5a2020-02-21 13:07:28 -0500184 int64_t getFrameNumber();
John Reck28912a52016-04-18 14:34:18 -0700185
Chris Craik06e2e9c2016-08-31 17:32:46 -0700186 void waitOnFences();
187
Stan Iliev23c38a92017-03-23 00:12:50 -0400188 IRenderPipeline* getRenderPipeline() { return mRenderPipeline.get(); }
189
chaviwe97e296c2021-08-20 12:15:48 -0500190 void addFrameCommitListener(std::function<void(bool)>&& func) {
191 mFrameCommitCallbacks.push_back(std::move(func));
John Reckcc2eee82018-05-17 10:44:00 -0700192 }
193
John Reck5cca8f22018-12-10 17:06:22 -0800194 void setPictureCapturedCallback(const std::function<void(sk_sp<SkPicture>&&)>& callback) {
195 mRenderPipeline->setPictureCapturedCallback(callback);
196 }
197
John Reck0fa0cbc2019-04-05 16:57:46 -0700198 void setForceDark(bool enable) { mUseForceDark = enable; }
John Reckbb3a3582018-09-26 11:21:08 -0700199
200 bool useForceDark() {
John Reckbb3a3582018-09-26 11:21:08 -0700201 return mUseForceDark;
202 }
203
Leon Scroggins III6c5864c2019-04-03 15:09:25 -0400204 SkISize getNextFrameSize() const;
205
Jorim Jaggi71db8892021-02-03 23:19:29 +0100206 // Called when SurfaceStats are available.
207 static void onSurfaceStatsAvailable(void* context, ASurfaceControl* control,
208 ASurfaceControlStats* stats);
209
Huihong Luo054b8d32021-02-24 18:48:12 -0800210 void setASurfaceTransactionCallback(
Huihong Luo4df41512021-06-24 10:04:32 -0700211 const std::function<bool(int64_t, int64_t, int64_t)>& callback) {
Huihong Luo054b8d32021-02-24 18:48:12 -0800212 mASurfaceTransactionCallback = callback;
213 }
214
215 bool mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control);
216
Huihong Luo34f42fd2021-05-03 14:47:36 -0700217 void setPrepareSurfaceControlForWebviewCallback(const std::function<void()>& callback) {
218 mPrepareSurfaceControlForWebviewCallback = callback;
219 }
220
221 void prepareSurfaceControlForWebview();
222
Huihong Luo054b8d32021-02-24 18:48:12 -0800223 static CanvasContext* getActiveContext();
224
John Reck23b797a2014-01-03 18:08:34 -0800225private:
Stan Iliev03de0742016-07-07 12:35:54 -0400226 CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
John Reck1bcacfd2017-11-03 10:12:19 -0700227 IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline);
Stan Iliev03de0742016-07-07 12:35:54 -0400228
John Recka5dda642014-05-22 15:43:54 -0700229 friend class RegisterFrameCallbackTask;
John Reck443a7142014-09-04 17:40:05 -0700230 // TODO: Replace with something better for layer & other GL object
231 // lifecycle tracking
232 friend class android::uirenderer::RenderState;
John Recka5dda642014-05-22 15:43:54 -0700233
John Reck2de950d2017-01-25 10:58:30 -0800234 void freePrefetchedLayers();
John Reck998a6d82014-08-28 15:35:53 -0700235
John Reck0def73a2016-07-01 16:19:13 -0700236 bool isSwapChainStuffed();
John Reck0b19a732019-03-07 17:18:25 -0800237 bool surfaceRequiresRedraw();
John Reckb36bfdd2020-07-23 13:47:49 -0700238 void setupPipelineSurface();
John Reck0def73a2016-07-01 16:19:13 -0700239
Stan Iliev768e3932016-07-08 21:34:52 -0400240 SkRect computeDirtyRect(const Frame& frame, SkRect* dirty);
Jorim Jaggi71db8892021-02-03 23:19:29 +0100241 void finishFrame(FrameInfo* frameInfo);
Stan Iliev768e3932016-07-08 21:34:52 -0400242
Siarhei Vishniakouf0cf18d2021-02-26 00:15:04 +0000243 /**
244 * Invoke 'reportFrameMetrics' on the last frame stored in 'mLast4FrameInfos'.
245 * Populate the 'presentTime' field before calling.
246 */
247 void reportMetricsWithPresentTime();
248
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000249 FrameInfo* getFrameInfoFromLast4(uint64_t frameNumber);
250
Fedor Kudasov52abc902019-06-26 16:59:16 +0100251 // The same type as Frame.mWidth and Frame.mHeight
252 int32_t mLastFrameWidth = 0;
253 int32_t mLastFrameHeight = 0;
Chris Craikddf22152015-10-14 17:42:47 -0700254
John Reck4f02bf42014-01-03 18:09:17 -0800255 RenderThread& mRenderThread;
Alec Mourif023a322019-11-25 10:02:21 -0800256 std::unique_ptr<ReliableSurface> mNativeSurface;
Huihong Luo5fdf7b82021-01-15 14:27:06 -0800257 // The SurfaceControl reference is passed from ViewRootImpl, can be set to
258 // NULL to remove the reference
259 ASurfaceControl* mSurfaceControl = nullptr;
Huihong Luo540fdf82021-06-25 13:59:39 -0700260 // id to track surface control changes and WebViewFunctor uses it to determine
261 // whether reparenting is needed
262 int32_t mSurfaceControlGenerationId = 0;
John Reck306f3312016-06-10 16:01:55 -0700263 // stopped indicates the CanvasContext will reject actual redraw operations,
264 // and defer repaint until it is un-stopped
John Reck8afcc762016-04-13 10:24:06 -0700265 bool mStopped = false;
Leon Scroggins III4afdd1c2018-05-14 14:59:30 -0400266 // Incremented each time the CanvasContext is stopped. Used to ignore
267 // delayed messages that are triggered after stopping.
268 int mGenerationID;
John Reck306f3312016-06-10 16:01:55 -0700269 // CanvasContext is dirty if it has received an update that it has not
270 // painted onto its surface.
271 bool mIsDirty = false;
Stan Iliev768e3932016-07-08 21:34:52 -0400272 SwapBehavior mSwapBehavior = SwapBehavior::kSwap_default;
John Recke486d932015-10-28 09:21:19 -0700273 struct SwapHistory {
274 SkRect damage;
275 nsecs_t vsyncTime;
John Reck0def73a2016-07-01 16:19:13 -0700276 nsecs_t swapCompletedTime;
277 nsecs_t dequeueDuration;
278 nsecs_t queueDuration;
John Recke486d932015-10-28 09:21:19 -0700279 };
280
John Reckca718a02019-10-21 10:14:58 -0700281 // Need at least 4 because we do quad buffer. Add a 5th for good measure.
Jiang Tian0815ba22021-12-03 18:18:16 +0800282 RingBuffer<SwapHistory, 7> mSwapHistory;
John Reck28912a52016-04-18 14:34:18 -0700283 int64_t mFrameNumber = -1;
John Reck41459192019-10-31 15:04:58 -0700284 int64_t mDamageId = 0;
John Reck4f02bf42014-01-03 18:09:17 -0800285
Chris Craik31635682016-07-19 17:59:12 -0700286 // last vsync for a dropped frame due to stuffed queue
287 nsecs_t mLastDropVsync = 0;
288
John Reck4f02bf42014-01-03 18:09:17 -0800289 bool mOpaque;
John Reckbb3a3582018-09-26 11:21:08 -0700290 bool mUseForceDark = false;
John Reckd9d7f122018-05-03 14:40:56 -0700291 LightInfo mLightInfo;
292 LightGeometry mLightGeometry = {{0, 0, 0}, 0};
Chris Craik98787e62015-11-13 10:55:30 -0800293
John Reckedc524c2015-03-18 15:24:33 -0700294 bool mHaveNewSurface = false;
John Recke4267ea2014-06-03 15:53:15 -0700295 DamageAccumulator mDamageAccumulator;
Chris Craik0b7e8242015-10-28 16:50:44 -0700296 LayerUpdateQueue mLayerUpdateQueue;
Chris Craik51d6a3d2014-12-22 17:16:56 -0800297 std::unique_ptr<AnimationContext> mAnimationContext;
John Recke45b1fd2014-04-15 09:50:16 -0700298
John Reck1bcacfd2017-11-03 10:12:19 -0700299 std::vector<sp<RenderNode>> mRenderNodes;
John Reckfe5e7b72014-05-23 17:42:28 -0700300
John Reckedc524c2015-03-18 15:24:33 -0700301 FrameInfo* mCurrentFrameInfo = nullptr;
Jorim Jaggi71db8892021-02-03 23:19:29 +0100302
303 // List of frames that are awaiting GPU completion reporting
304 RingBuffer<std::pair<FrameInfo*, int64_t>, 4> mLast4FrameInfos
305 GUARDED_BY(mLast4FrameInfosMutex);
306 std::mutex mLast4FrameInfosMutex;
307
John Reckb36016c2015-03-11 08:50:53 -0700308 std::string mName;
John Reckedc524c2015-03-18 15:24:33 -0700309 JankTracker mJankTracker;
John Reck4c9e59d2015-05-12 07:17:50 -0700310 FrameInfoVisualizer mProfiler;
Siarhei Vishniakou07d35cb2021-07-03 02:22:12 +0000311 std::unique_ptr<FrameMetricsReporter> mFrameMetricsReporter
312 GUARDED_BY(mFrameMetricsReporterMutex);
Jorim Jaggie4a52712021-05-31 17:57:50 +0200313 std::mutex mFrameMetricsReporterMutex;
John Reck998a6d82014-08-28 15:35:53 -0700314
John Reck51f2d602016-04-06 07:50:47 -0700315 std::set<RenderNode*> mPrefetchedLayers;
Skuhneea7a7fb2015-08-28 07:10:31 -0700316
317 // Stores the bounds of the main content.
Skuhneb8160872015-09-22 09:51:39 -0700318 Rect mContentDrawBounds;
John Reck38f6c032016-03-17 10:23:49 -0700319
John Reck322b8ab2019-03-14 13:15:28 -0700320 std::vector<std::future<void>> mFrameFences;
Stan Iliev768e3932016-07-08 21:34:52 -0400321 std::unique_ptr<IRenderPipeline> mRenderPipeline;
John Reckcc2eee82018-05-17 10:44:00 -0700322
chaviwe97e296c2021-08-20 12:15:48 -0500323 std::vector<std::function<void(bool)>> mFrameCommitCallbacks;
Jorim Jaggi71db8892021-02-03 23:19:29 +0100324
325 // If set to true, we expect that callbacks into onSurfaceStatsAvailable
326 bool mExpectSurfaceStats = false;
Huihong Luo054b8d32021-02-24 18:48:12 -0800327
Huihong Luo4df41512021-06-24 10:04:32 -0700328 std::function<bool(int64_t, int64_t, int64_t)> mASurfaceTransactionCallback;
Huihong Luo34f42fd2021-05-03 14:47:36 -0700329 std::function<void()> mPrepareSurfaceControlForWebviewCallback;
330
Nader Jawaddd1fcab2021-06-10 18:54:23 -0700331 void cleanupResources();
John Reck23b797a2014-01-03 18:08:34 -0800332};
333
334} /* namespace renderthread */
335} /* namespace uirenderer */
336} /* namespace android */