Merge "BufferStateLayer: Use mCurrentState for HeadFrameNumber"

    void updateCloneBufferInfo() override;

    void updateCloneBufferInfo() override;

    uint64_t mPreviousFrameNumber = 0;

    uint64_t mPreviousFrameNumber = 0;

    virtual uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

private:

private:

    // Returns true if this layer requires filtering

    // Returns true if this layer requires filtering

    bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;

    bool needsFiltering(const sp<const DisplayDevice>& displayDevice) const override;

    uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

    // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame

    // BufferStateLayers can return Rect::INVALID_RECT if the layer does not have a display frame

    // and its parent layer is not bounded

    // and its parent layer is not bounded

    Rect getBufferSize(const State& s) const override;

    Rect getBufferSize(const State& s) const override;

    return mDrawingState.frameNumber;

    return mDrawingState.frameNumber;

}

}

/**

 * This is the frameNumber used for deferred transaction signalling. We need to use this because

 * of cases where we defer a transaction for a surface to itself. In the BLAST world this

 * may not make a huge amount of sense (Why not just merge the Buffer transaction with the

 * deferred transaction?) but this is an important legacy use case, for example moving

 * a window at the same time it draws makes use of this kind of technique. So anyway

 * imagine we have something like this:

 *

 * Transaction { // containing

 *     Buffer -> frameNumber = 2

 *     DeferTransactionUntil -> frameNumber = 2

 *     Random other stuff

 *  }

 * Now imagine getHeadFrameNumber returned mDrawingState.mFrameNumber (or mCurrentFrameNumber).

 * Prior to doTransaction SurfaceFlinger will call notifyAvailableFrames, but because we

 * haven't swapped mCurrentState to mDrawingState yet we will think the sync point

 * is not ready. So we will return false from applyPendingState and not swap

 * current state to drawing state. But because we don't swap current state

 * to drawing state the number will never update and we will be stuck. This way

 * we can see we need to return the frame number for the buffer we are about

 * to apply.

 */

uint64_t BufferStateLayer::getHeadFrameNumber(nsecs_t /* expectedPresentTime */) const {

    return mCurrentState.frameNumber;

}

bool BufferStateLayer::getAutoRefresh() const {

bool BufferStateLayer::getAutoRefresh() const {

    // TODO(marissaw): support shared buffer mode

    // TODO(marissaw): support shared buffer mode

    return false;

    return false;

protected:

protected:

    void gatherBufferInfo() override;

    void gatherBufferInfo() override;

    uint64_t getHeadFrameNumber(nsecs_t expectedPresentTime) const;

private:

private:

    bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,

    bool updateFrameEventHistory(const sp<Fence>& acquireFence, nsecs_t postedTime,