libs/hwui/renderthread/CanvasContext.cpp

   1 /*
   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
  17 #include <GpuMemoryTracker.h>
  18 #include "CanvasContext.h"
  19
  20 #include "AnimationContext.h"
  21 #include "Caches.h"
  22 #include "DeferredLayerUpdater.h"
  23 #include "EglManager.h"
  24 #include "LayerUpdateQueue.h"
  25 #include "LayerRenderer.h"
  26 #include "OpenGLRenderer.h"
  27 #include "Properties.h"
  28 #include "RenderThread.h"
  29 #include "hwui/Canvas.h"
  30 #include "renderstate/RenderState.h"
  31 #include "renderstate/Stencil.h"
  32 #include "protos/hwui.pb.h"
  33 #include "utils/GLUtils.h"
  34 #include "utils/TimeUtils.h"
  35
  36 #include <cutils/properties.h>
  37 #include <google/protobuf/io/zero_copy_stream_impl.h>
  38 #include <private/hwui/DrawGlInfo.h>
  39 #include <strings.h>
  40
  41 #include <algorithm>
  42 #include <fcntl.h>
  43 #include <sys/stat.h>
  44
  45 #include <cstdlib>
  46
  47 #define TRIM_MEMORY_COMPLETE 80
  48 #define TRIM_MEMORY_UI_HIDDEN 20
  49
  50 #define ENABLE_RENDERNODE_SERIALIZATION false
  51
  52 #define LOG_FRAMETIME_MMA 0
  53
  54 #if LOG_FRAMETIME_MMA
  55 static float sBenchMma = 0;
  56 static int sFrameCount = 0;
  57 static const float NANOS_PER_MILLIS_F = 1000000.0f;
  58 #endif
  59
  60 namespace android {
  61 namespace uirenderer {
  62 namespace renderthread {
  63
  64 CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
  65         RenderNode* rootRenderNode, IContextFactory* contextFactory)
  66         : mRenderThread(thread)
  67         , mEglManager(thread.eglManager())
  68         , mOpaque(!translucent)
  69         , mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
  70         , mJankTracker(thread.timeLord().frameIntervalNanos())
  71         , mProfiler(mFrames)
  72         , mContentDrawBounds(0, 0, 0, 0) {
  73     mRenderNodes.emplace_back(rootRenderNode);
  74     mRenderThread.renderState().registerCanvasContext(this);
  75     mProfiler.setDensity(mRenderThread.mainDisplayInfo().density);
  76 }
  77
  78 CanvasContext::~CanvasContext() {
  79     destroy(nullptr);
  80     mRenderThread.renderState().unregisterCanvasContext(this);
  81 }
  82
  83 void CanvasContext::destroy(TreeObserver* observer) {
  84     stopDrawing();
  85     setSurface(nullptr);
  86     freePrefetchedLayers(observer);
  87     destroyHardwareResources(observer);
  88     mAnimationContext->destroy();
  89 #if !HWUI_NEW_OPS
  90     if (mCanvas) {
  91         delete mCanvas;
  92         mCanvas = nullptr;
  93     }
  94 #endif
  95 }
  96
  97 void CanvasContext::setSurface(Surface* surface) {
  98     ATRACE_CALL();
  99
 100     mNativeSurface = surface;
 101
 102     if (mEglSurface != EGL_NO_SURFACE) {
 103         mEglManager.destroySurface(mEglSurface);
 104         mEglSurface = EGL_NO_SURFACE;
 105     }
 106
 107     if (surface) {
 108         mEglSurface = mEglManager.createSurface(surface);
 109     }
 110
 111     mFrameNumber = -1;
 112
 113     if (mEglSurface != EGL_NO_SURFACE) {
 114         const bool preserveBuffer = (mSwapBehavior != kSwap_discardBuffer);
 115         mBufferPreserved = mEglManager.setPreserveBuffer(mEglSurface, preserveBuffer);
 116         mHaveNewSurface = true;
 117         mSwapHistory.clear();
 118     } else {
 119         mRenderThread.removeFrameCallback(this);
 120     }
 121 }
 122
 123 void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) {
 124     mSwapBehavior = swapBehavior;
 125 }
 126
 127 void CanvasContext::initialize(Surface* surface) {
 128     setSurface(surface);
 129 #if !HWUI_NEW_OPS
 130     if (mCanvas) return;
 131     mCanvas = new OpenGLRenderer(mRenderThread.renderState());
 132     mCanvas->initProperties();
 133 #endif
 134 }
 135
 136 void CanvasContext::updateSurface(Surface* surface) {
 137     setSurface(surface);
 138 }
 139
 140 bool CanvasContext::pauseSurface(Surface* surface) {
 141     return mRenderThread.removeFrameCallback(this);
 142 }
 143
 144 void CanvasContext::setStopped(bool stopped) {
 145     if (mStopped != stopped) {
 146         mStopped = stopped;
 147         if (mStopped) {
 148             mRenderThread.removeFrameCallback(this);
 149             if (mEglManager.isCurrent(mEglSurface)) {
 150                 mEglManager.makeCurrent(EGL_NO_SURFACE);
 151             }
 152         } else if (mIsDirty && hasSurface()) {
 153             mRenderThread.postFrameCallback(this);
 154         }
 155     }
 156 }
 157
 158 // TODO: don't pass viewport size, it's automatic via EGL
 159 void CanvasContext::setup(int width, int height, float lightRadius,
 160         uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
 161 #if HWUI_NEW_OPS
 162     mLightGeometry.radius = lightRadius;
 163     mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
 164     mLightInfo.spotShadowAlpha = spotShadowAlpha;
 165 #else
 166     if (!mCanvas) return;
 167     mCanvas->initLight(lightRadius, ambientShadowAlpha, spotShadowAlpha);
 168 #endif
 169 }
 170
 171 void CanvasContext::setLightCenter(const Vector3& lightCenter) {
 172 #if HWUI_NEW_OPS
 173     mLightGeometry.center = lightCenter;
 174 #else
 175     if (!mCanvas) return;
 176     mCanvas->setLightCenter(lightCenter);
 177 #endif
 178 }
 179
 180 void CanvasContext::setOpaque(bool opaque) {
 181     mOpaque = opaque;
 182 }
 183
 184 bool CanvasContext::makeCurrent() {
 185     if (mStopped) return false;
 186
 187     // TODO: Figure out why this workaround is needed, see b/13913604
 188     // In the meantime this matches the behavior of GLRenderer, so it is not a regression
 189     EGLint error = 0;
 190     mHaveNewSurface |= mEglManager.makeCurrent(mEglSurface, &error);
 191     if (error) {
 192         setSurface(nullptr);
 193     }
 194     return !error;
 195 }
 196
 197 static bool wasSkipped(FrameInfo* info) {
 198     return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
 199 }
 200
 201 void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
 202         int64_t syncQueued, RenderNode* target) {
 203     mRenderThread.removeFrameCallback(this);
 204
 205     // If the previous frame was dropped we don't need to hold onto it, so
 206     // just keep using the previous frame's structure instead
 207     if (!wasSkipped(mCurrentFrameInfo)) {
 208         mCurrentFrameInfo = &mFrames.next();
 209     }
 210     mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo);
 211     mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued;
 212     mCurrentFrameInfo->markSyncStart();
 213
 214     info.damageAccumulator = &mDamageAccumulator;
 215 #if HWUI_NEW_OPS
 216     info.layerUpdateQueue = &mLayerUpdateQueue;
 217 #else
 218     info.renderer = mCanvas;
 219 #endif
 220
 221     mAnimationContext->startFrame(info.mode);
 222     for (const sp<RenderNode>& node : mRenderNodes) {
 223         // Only the primary target node will be drawn full - all other nodes would get drawn in
 224         // real time mode. In case of a window, the primary node is the window content and the other
 225         // node(s) are non client / filler nodes.
 226         info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
 227         node->prepareTree(info);
 228         GL_CHECKPOINT(MODERATE);
 229     }
 230     mAnimationContext->runRemainingAnimations(info);
 231     GL_CHECKPOINT(MODERATE);
 232
 233     freePrefetchedLayers(info.observer);
 234     GL_CHECKPOINT(MODERATE);
 235
 236     mIsDirty = true;
 237
 238     if (CC_UNLIKELY(!mNativeSurface.get())) {
 239         mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
 240         info.out.canDrawThisFrame = false;
 241         return;
 242     }
 243
 244     if (CC_LIKELY(mSwapHistory.size())) {
 245         nsecs_t latestVsync = mRenderThread.timeLord().latestVsync();
 246         const SwapHistory& lastSwap = mSwapHistory.back();
 247         nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync);
 248         // The slight fudge-factor is to deal with cases where
 249         // the vsync was estimated due to being slow handling the signal.
 250         // See the logic in TimeLord#computeFrameTimeNanos or in
 251         // Choreographer.java for details on when this happens
 252         if (vsyncDelta < 2_ms) {
 253             // Already drew for this vsync pulse, UI draw request missed
 254             // the deadline for RT animations
 255             info.out.canDrawThisFrame = false;
 256         } else if (lastSwap.swapTime < latestVsync) {
 257             info.out.canDrawThisFrame = true;
 258         } else {
 259             // We're maybe behind? Find out for sure
 260             int runningBehind = 0;
 261             // TODO: Have this method be on Surface, too, not just ANativeWindow...
 262             ANativeWindow* window = mNativeSurface.get();
 263             window->query(window, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &runningBehind);
 264             info.out.canDrawThisFrame = !runningBehind;
 265         }
 266     } else {
 267         info.out.canDrawThisFrame = true;
 268     }
 269
 270     if (!info.out.canDrawThisFrame) {
 271         mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
 272     }
 273
 274     if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
 275         if (!info.out.requiresUiRedraw) {
 276             // If animationsNeedsRedraw is set don't bother posting for an RT anim
 277             // as we will just end up fighting the UI thread.
 278             mRenderThread.postFrameCallback(this);
 279         }
 280     }
 281 }
 282
 283 void CanvasContext::stopDrawing() {
 284     mRenderThread.removeFrameCallback(this);
 285 }
 286
 287 void CanvasContext::notifyFramePending() {
 288     ATRACE_CALL();
 289     mRenderThread.pushBackFrameCallback(this);
 290 }
 291
 292 void CanvasContext::draw() {
 293 #if !HWUI_NEW_OPS
 294     LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
 295             "drawRenderNode called on a context with no canvas or surface!");
 296 #endif
 297
 298     SkRect dirty;
 299     mDamageAccumulator.finish(&dirty);
 300
 301     // TODO: Re-enable after figuring out cause of b/22592975
 302 //    if (dirty.isEmpty() && Properties::skipEmptyFrames) {
 303 //        mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
 304 //        return;
 305 //    }
 306
 307     mCurrentFrameInfo->markIssueDrawCommandsStart();
 308
 309     Frame frame = mEglManager.beginFrame(mEglSurface);
 310
 311     if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) {
 312         // can't rely on prior content of window if viewport size changes
 313         dirty.setEmpty();
 314         mLastFrameWidth = frame.width();
 315         mLastFrameHeight = frame.height();
 316     } else if (mHaveNewSurface || frame.bufferAge() == 0) {
 317         // New surface needs a full draw
 318         dirty.setEmpty();
 319     } else {
 320         if (!dirty.isEmpty() && !dirty.intersect(0, 0, frame.width(), frame.height())) {
 321             ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?",
 322                     SK_RECT_ARGS(dirty), frame.width(), frame.height());
 323             dirty.setEmpty();
 324         }
 325         profiler().unionDirty(&dirty);
 326     }
 327
 328     if (dirty.isEmpty()) {
 329         dirty.set(0, 0, frame.width(), frame.height());
 330     }
 331
 332     // At this point dirty is the area of the screen to update. However,
 333     // the area of the frame we need to repaint is potentially different, so
 334     // stash the screen area for later
 335     SkRect screenDirty(dirty);
 336
 337     // If the buffer age is 0 we do a full-screen repaint (handled above)
 338     // If the buffer age is 1 the buffer contents are the same as they were
 339     // last frame so there's nothing to union() against
 340     // Therefore we only care about the > 1 case.
 341     if (frame.bufferAge() > 1) {
 342         if (frame.bufferAge() > (int) mSwapHistory.size()) {
 343             // We don't have enough history to handle this old of a buffer
 344             // Just do a full-draw
 345             dirty.set(0, 0, frame.width(), frame.height());
 346         } else {
 347             // At this point we haven't yet added the latest frame
 348             // to the damage history (happens below)
 349             // So we need to damage
 350             for (int i = mSwapHistory.size() - 1;
 351                     i > ((int) mSwapHistory.size()) - frame.bufferAge(); i--) {
 352                 dirty.join(mSwapHistory[i].damage);
 353             }
 354         }
 355     }
 356
 357     mEglManager.damageFrame(frame, dirty);
 358
 359 #if HWUI_NEW_OPS
 360     auto& caches = Caches::getInstance();
 361     FrameBuilder frameBuilder(dirty, frame.width(), frame.height(), mLightGeometry, caches);
 362
 363     frameBuilder.deferLayers(mLayerUpdateQueue);
 364     mLayerUpdateQueue.clear();
 365
 366     frameBuilder.deferRenderNodeScene(mRenderNodes, mContentDrawBounds);
 367
 368     BakedOpRenderer renderer(caches, mRenderThread.renderState(),
 369             mOpaque, mLightInfo);
 370     frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
 371     profiler().draw(&renderer);
 372     bool drew = renderer.didDraw();
 373
 374     // post frame cleanup
 375     caches.clearGarbage();
 376     caches.pathCache.trim();
 377     caches.tessellationCache.trim();
 378
 379 #if DEBUG_MEMORY_USAGE
 380     mCaches.dumpMemoryUsage();
 381 #else
 382     if (CC_UNLIKELY(Properties::debugLevel & kDebugMemory)) {
 383         caches.dumpMemoryUsage();
 384     }
 385 #endif
 386
 387 #else
 388     mCanvas->prepareDirty(frame.width(), frame.height(),
 389             dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);
 390
 391     Rect outBounds;
 392     // It there are multiple render nodes, they are laid out as follows:
 393     // #0 - backdrop (content + caption)
 394     // #1 - content (positioned at (0,0) and clipped to - its bounds mContentDrawBounds)
 395     // #2 - additional overlay nodes
 396     // Usually the backdrop cannot be seen since it will be entirely covered by the content. While
 397     // resizing however it might become partially visible. The following render loop will crop the
 398     // backdrop against the content and draw the remaining part of it. It will then draw the content
 399     // cropped to the backdrop (since that indicates a shrinking of the window).
 400     //
 401     // Additional nodes will be drawn on top with no particular clipping semantics.
 402
 403     // The bounds of the backdrop against which the content should be clipped.
 404     Rect backdropBounds = mContentDrawBounds;
 405     // Usually the contents bounds should be mContentDrawBounds - however - we will
 406     // move it towards the fixed edge to give it a more stable appearance (for the moment).
 407     Rect contentBounds;
 408     // If there is no content bounds we ignore the layering as stated above and start with 2.
 409     int layer = (mContentDrawBounds.isEmpty() || mRenderNodes.size() == 1) ? 2 : 0;
 410     // Draw all render nodes. Note that
 411     for (const sp<RenderNode>& node : mRenderNodes) {
 412         if (layer == 0) { // Backdrop.
 413             // Draw the backdrop clipped to the inverse content bounds, but assume that the content
 414             // was moved to the upper left corner.
 415             const RenderProperties& properties = node->properties();
 416             Rect targetBounds(properties.getLeft(), properties.getTop(),
 417                               properties.getRight(), properties.getBottom());
 418             // Move the content bounds towards the fixed corner of the backdrop.
 419             const int x = targetBounds.left;
 420             const int y = targetBounds.top;
 421             contentBounds.set(x, y, x + mContentDrawBounds.getWidth(),
 422                                     y + mContentDrawBounds.getHeight());
 423             // Remember the intersection of the target bounds and the intersection bounds against
 424             // which we have to crop the content.
 425             backdropBounds.set(x, y, x + backdropBounds.getWidth(), y + backdropBounds.getHeight());
 426             backdropBounds.doIntersect(targetBounds);
 427             // Check if we have to draw something on the left side ...
 428             if (targetBounds.left < contentBounds.left) {
 429                 mCanvas->save(SaveFlags::Clip);
 430                 if (mCanvas->clipRect(targetBounds.left, targetBounds.top,
 431                                       contentBounds.left, targetBounds.bottom,
 432                                       SkRegion::kIntersect_Op)) {
 433                     mCanvas->drawRenderNode(node.get(), outBounds);
 434                 }
 435                 // Reduce the target area by the area we have just painted.
 436                 targetBounds.left = std::min(contentBounds.left, targetBounds.right);
 437                 mCanvas->restore();
 438             }
 439             // ... or on the right side ...
 440             if (targetBounds.right > contentBounds.right &&
 441                 !targetBounds.isEmpty()) {
 442                 mCanvas->save(SaveFlags::Clip);
 443                 if (mCanvas->clipRect(contentBounds.right, targetBounds.top,
 444                                       targetBounds.right, targetBounds.bottom,
 445                                       SkRegion::kIntersect_Op)) {
 446                     mCanvas->drawRenderNode(node.get(), outBounds);
 447                 }
 448                 // Reduce the target area by the area we have just painted.
 449                 targetBounds.right = std::max(targetBounds.left, contentBounds.right);
 450                 mCanvas->restore();
 451             }
 452             // ... or at the top ...
 453             if (targetBounds.top < contentBounds.top &&
 454                 !targetBounds.isEmpty()) {
 455                 mCanvas->save(SaveFlags::Clip);
 456                 if (mCanvas->clipRect(targetBounds.left, targetBounds.top, targetBounds.right,
 457                                       contentBounds.top,
 458                                       SkRegion::kIntersect_Op)) {
 459                     mCanvas->drawRenderNode(node.get(), outBounds);
 460                 }
 461                 // Reduce the target area by the area we have just painted.
 462                 targetBounds.top = std::min(contentBounds.top, targetBounds.bottom);
 463                 mCanvas->restore();
 464             }
 465             // ... or at the bottom.
 466             if (targetBounds.bottom > contentBounds.bottom &&
 467                 !targetBounds.isEmpty()) {
 468                 mCanvas->save(SaveFlags::Clip);
 469                 if (mCanvas->clipRect(targetBounds.left, contentBounds.bottom, targetBounds.right,
 470                                       targetBounds.bottom, SkRegion::kIntersect_Op)) {
 471                     mCanvas->drawRenderNode(node.get(), outBounds);
 472                 }
 473                 mCanvas->restore();
 474             }
 475         } else if (layer == 1) { // Content
 476             // It gets cropped against the bounds of the backdrop to stay inside.
 477             mCanvas->save(SaveFlags::MatrixClip);
 478
 479             // We shift and clip the content to match its final location in the window.
 480             const float left = mContentDrawBounds.left;
 481             const float top = mContentDrawBounds.top;
 482             const float dx = backdropBounds.left - left;
 483             const float dy = backdropBounds.top - top;
 484             const float width = backdropBounds.getWidth();
 485             const float height = backdropBounds.getHeight();
 486
 487             mCanvas->translate(dx, dy);
 488             if (mCanvas->clipRect(left, top, left + width, top + height, SkRegion::kIntersect_Op)) {
 489                 mCanvas->drawRenderNode(node.get(), outBounds);
 490             }
 491             mCanvas->restore();
 492         } else { // draw the rest on top at will!
 493             mCanvas->drawRenderNode(node.get(), outBounds);
 494         }
 495         layer++;
 496     }
 497
 498     profiler().draw(mCanvas);
 499
 500     bool drew = mCanvas->finish();
 501 #endif
 502
 503     waitOnFences();
 504
 505     GL_CHECKPOINT(LOW);
 506
 507     // Even if we decided to cancel the frame, from the perspective of jank
 508     // metrics the frame was swapped at this point
 509     mCurrentFrameInfo->markSwapBuffers();
 510     mIsDirty = false;
 511
 512     if (drew || mEglManager.damageRequiresSwap()) {
 513         if (CC_UNLIKELY(!mEglManager.swapBuffers(frame, screenDirty))) {
 514             setSurface(nullptr);
 515         }
 516         SwapHistory& swap = mSwapHistory.next();
 517         swap.damage = screenDirty;
 518         swap.swapTime = systemTime(CLOCK_MONOTONIC);
 519         swap.vsyncTime = mRenderThread.timeLord().latestVsync();
 520         mHaveNewSurface = false;
 521         mFrameNumber = -1;
 522     }
 523
 524     // TODO: Use a fence for real completion?
 525     mCurrentFrameInfo->markFrameCompleted();
 526
 527 #if LOG_FRAMETIME_MMA
 528     float thisFrame = mCurrentFrameInfo->duration(
 529             FrameInfoIndex::IssueDrawCommandsStart,
 530             FrameInfoIndex::FrameCompleted) / NANOS_PER_MILLIS_F;
 531     if (sFrameCount) {
 532         sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
 533     } else {
 534         sBenchMma = thisFrame;
 535     }
 536     if (++sFrameCount == 10) {
 537         sFrameCount = 1;
 538         ALOGD("Average frame time: %.4f", sBenchMma);
 539     }
 540 #endif
 541
 542     mJankTracker.addFrame(*mCurrentFrameInfo);
 543     mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo);
 544     if (CC_UNLIKELY(mFrameMetricsReporter.get() != nullptr)) {
 545         mFrameMetricsReporter->reportFrameMetrics(mCurrentFrameInfo->data());
 546     }
 547
 548     GpuMemoryTracker::onFrameCompleted();
 549 }
 550
 551 // Called by choreographer to do an RT-driven animation
 552 void CanvasContext::doFrame() {
 553 #if HWUI_NEW_OPS
 554     if (CC_UNLIKELY(mEglSurface == EGL_NO_SURFACE)) return;
 555 #else
 556     if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) return;
 557 #endif
 558     prepareAndDraw(nullptr);
 559 }
 560
 561 void CanvasContext::prepareAndDraw(RenderNode* node) {
 562     ATRACE_CALL();
 563
 564     nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
 565     int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
 566     UiFrameInfoBuilder(frameInfo)
 567         .addFlag(FrameInfoFlags::RTAnimation)
 568         .setVsync(vsync, vsync);
 569
 570     TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
 571     prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);
 572     if (info.out.canDrawThisFrame) {
 573         draw();
 574     }
 575 }
 576
 577 void CanvasContext::invokeFunctor(RenderThread& thread, Functor* functor) {
 578     ATRACE_CALL();
 579     DrawGlInfo::Mode mode = DrawGlInfo::kModeProcessNoContext;
 580     if (thread.eglManager().hasEglContext()) {
 581         mode = DrawGlInfo::kModeProcess;
 582     }
 583
 584     thread.renderState().invokeFunctor(functor, mode, nullptr);
 585 }
 586
 587 void CanvasContext::markLayerInUse(RenderNode* node) {
 588     if (mPrefetchedLayers.erase(node)) {
 589         node->decStrong(nullptr);
 590     }
 591 }
 592
 593 void CanvasContext::freePrefetchedLayers(TreeObserver* observer) {
 594     if (mPrefetchedLayers.size()) {
 595         for (auto& node : mPrefetchedLayers) {
 596             ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
 597                     node->getName());
 598             node->destroyHardwareResources(observer);
 599             node->decStrong(observer);
 600         }
 601         mPrefetchedLayers.clear();
 602     }
 603 }
 604
 605 void CanvasContext::buildLayer(RenderNode* node, TreeObserver* observer) {
 606     ATRACE_CALL();
 607     if (!mEglManager.hasEglContext()) return;
 608 #if !HWUI_NEW_OPS
 609     if (!mCanvas) return;
 610 #endif
 611
 612     // buildLayer() will leave the tree in an unknown state, so we must stop drawing
 613     stopDrawing();
 614
 615     TreeInfo info(TreeInfo::MODE_FULL, *this);
 616     info.damageAccumulator = &mDamageAccumulator;
 617     info.observer = observer;
 618 #if HWUI_NEW_OPS
 619     info.layerUpdateQueue = &mLayerUpdateQueue;
 620 #else
 621     info.renderer = mCanvas;
 622 #endif
 623     info.runAnimations = false;
 624     node->prepareTree(info);
 625     SkRect ignore;
 626     mDamageAccumulator.finish(&ignore);
 627     // Tickle the GENERIC property on node to mark it as dirty for damaging
 628     // purposes when the frame is actually drawn
 629     node->setPropertyFieldsDirty(RenderNode::GENERIC);
 630
 631 #if HWUI_NEW_OPS
 632     static const std::vector< sp<RenderNode> > emptyNodeList;
 633     auto& caches = Caches::getInstance();
 634     FrameBuilder frameBuilder(mLayerUpdateQueue, mLightGeometry, caches);
 635     mLayerUpdateQueue.clear();
 636     BakedOpRenderer renderer(caches, mRenderThread.renderState(),
 637             mOpaque, mLightInfo);
 638     LOG_ALWAYS_FATAL_IF(renderer.didDraw(), "shouldn't draw in buildlayer case");
 639     frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
 640 #else
 641     mCanvas->markLayersAsBuildLayers();
 642     mCanvas->flushLayerUpdates();
 643 #endif
 644
 645     node->incStrong(nullptr);
 646     mPrefetchedLayers.insert(node);
 647 }
 648
 649 bool CanvasContext::copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap) {
 650     layer->apply();
 651     return LayerRenderer::copyLayer(mRenderThread.renderState(), layer->backingLayer(), bitmap);
 652 }
 653
 654 void CanvasContext::destroyHardwareResources(TreeObserver* observer) {
 655     stopDrawing();
 656     if (mEglManager.hasEglContext()) {
 657         freePrefetchedLayers(observer);
 658         for (const sp<RenderNode>& node : mRenderNodes) {
 659             node->destroyHardwareResources(observer);
 660         }
 661         Caches& caches = Caches::getInstance();
 662         // Make sure to release all the textures we were owning as there won't
 663         // be another draw
 664         caches.textureCache.resetMarkInUse(this);
 665         mRenderThread.renderState().flush(Caches::FlushMode::Layers);
 666     }
 667 }
 668
 669 void CanvasContext::trimMemory(RenderThread& thread, int level) {
 670     // No context means nothing to free
 671     if (!thread.eglManager().hasEglContext()) return;
 672
 673     ATRACE_CALL();
 674     if (level >= TRIM_MEMORY_COMPLETE) {
 675         thread.renderState().flush(Caches::FlushMode::Full);
 676         thread.eglManager().destroy();
 677     } else if (level >= TRIM_MEMORY_UI_HIDDEN) {
 678         thread.renderState().flush(Caches::FlushMode::Moderate);
 679     }
 680 }
 681
 682 void CanvasContext::runWithGlContext(RenderTask* task) {
 683     LOG_ALWAYS_FATAL_IF(!mEglManager.hasEglContext(),
 684             "GL context not initialized!");
 685     task->run();
 686 }
 687
 688 Layer* CanvasContext::createTextureLayer() {
 689     mEglManager.initialize();
 690     return LayerRenderer::createTextureLayer(mRenderThread.renderState());
 691 }
 692
 693 void CanvasContext::setTextureAtlas(RenderThread& thread,
 694         const sp<GraphicBuffer>& buffer, int64_t* map, size_t mapSize) {
 695     thread.eglManager().setTextureAtlas(buffer, map, mapSize);
 696 }
 697
 698 void CanvasContext::dumpFrames(int fd) {
 699     FILE* file = fdopen(fd, "a");
 700     fprintf(file, "\n\n---PROFILEDATA---\n");
 701     for (size_t i = 0; i < static_cast<size_t>(FrameInfoIndex::NumIndexes); i++) {
 702         fprintf(file, "%s", FrameInfoNames[i].c_str());
 703         fprintf(file, ",");
 704     }
 705     for (size_t i = 0; i < mFrames.size(); i++) {
 706         FrameInfo& frame = mFrames[i];
 707         if (frame[FrameInfoIndex::SyncStart] == 0) {
 708             continue;
 709         }
 710         fprintf(file, "\n");
 711         for (int i = 0; i < static_cast<int>(FrameInfoIndex::NumIndexes); i++) {
 712             fprintf(file, "%" PRId64 ",", frame[i]);
 713         }
 714     }
 715     fprintf(file, "\n---PROFILEDATA---\n\n");
 716     fflush(file);
 717 }
 718
 719 void CanvasContext::resetFrameStats() {
 720     mFrames.clear();
 721     mRenderThread.jankTracker().reset();
 722 }
 723
 724 void CanvasContext::serializeDisplayListTree() {
 725 #if ENABLE_RENDERNODE_SERIALIZATION
 726     using namespace google::protobuf::io;
 727     char package[128];
 728     // Check whether tracing is enabled for this process.
 729     FILE * file = fopen("/proc/self/cmdline", "r");
 730     if (file) {
 731         if (!fgets(package, 128, file)) {
 732             ALOGE("Error reading cmdline: %s (%d)", strerror(errno), errno);
 733             fclose(file);
 734             return;
 735         }
 736         fclose(file);
 737     } else {
 738         ALOGE("Error opening /proc/self/cmdline: %s (%d)", strerror(errno),
 739                 errno);
 740         return;
 741     }
 742     char path[1024];
 743     snprintf(path, 1024, "/data/data/%s/cache/rendertree_dump", package);
 744     int fd = open(path, O_CREAT | O_WRONLY, S_IRWXU | S_IRGRP | S_IROTH);
 745     if (fd == -1) {
 746         ALOGD("Failed to open '%s'", path);
 747         return;
 748     }
 749     proto::RenderNode tree;
 750     // TODO: Streaming writes?
 751     mRootRenderNode->copyTo(&tree);
 752     std::string data = tree.SerializeAsString();
 753     write(fd, data.c_str(), data.length());
 754     close(fd);
 755 #endif
 756 }
 757
 758 void CanvasContext::waitOnFences() {
 759     if (mFrameFences.size()) {
 760         ATRACE_CALL();
 761         for (auto& fence : mFrameFences) {
 762             fence->getResult();
 763         }
 764         mFrameFences.clear();
 765     }
 766 }
 767
 768 class CanvasContext::FuncTaskProcessor : public TaskProcessor<bool> {
 769 public:
 770     FuncTaskProcessor(Caches& caches)
 771             : TaskProcessor<bool>(&caches.tasks) {}
 772
 773     virtual void onProcess(const sp<Task<bool> >& task) override {
 774         FuncTask* t = static_cast<FuncTask*>(task.get());
 775         t->func();
 776         task->setResult(true);
 777     }
 778 };
 779
 780 void CanvasContext::enqueueFrameWork(std::function<void()>&& func) {
 781     if (!mFrameWorkProcessor.get()) {
 782         mFrameWorkProcessor = new FuncTaskProcessor(Caches::getInstance());
 783     }
 784     sp<FuncTask> task(new FuncTask());
 785     task->func = func;
 786     mFrameWorkProcessor->add(task);
 787 }
 788
 789 int64_t CanvasContext::getFrameNumber() {
 790     // mFrameNumber is reset to -1 when the surface changes or we swap buffers
 791     if (mFrameNumber == -1 && mNativeSurface.get()) {
 792         mFrameNumber = static_cast<int64_t>(mNativeSurface->getNextFrameNumber());
 793     }
 794     return mFrameNumber;
 795 }
 796
 797 } /* namespace renderthread */
 798 } /* namespace uirenderer */
 799 } /* namespace android */