Snap for 5165440 from 66e735e3 to qt-release

struct DisplaySettings {

    // Rectangle describing the physical display. We will project from the

    // logical clip onto this rectangle.

    Rect physicalDisplay;

    Rect physicalDisplay = Rect::INVALID_RECT;

    // Rectangle bounded by the x,y- clipping planes in the logical display, so

    // that the orthographic projection matrix can be computed. When

    // constructing this matrix, z-coordinate bound are assumed to be at z=0 and

    // z=1.

    Rect clip;

    Rect clip = Rect::INVALID_RECT;

    // Global transform to apply to all layers.

    mat4 globalTransform;

    mat4 globalTransform = mat4();

    // Maximum luminance pulled from the display's HDR capabilities.

    float maxLuminence;

    float maxLuminence = 1.0f;

    // Output dataspace that will be populated if wide color gamut is used, or

    // DataSpace::UNKNOWN otherwise.

    ui::Dataspace outputDataspace;

    ui::Dataspace outputDataspace = ui::Dataspace::UNKNOWN;

    // Additional color transform to apply in linear space after transforming

    // to the output dataspace.

    mat4 colorTransform;

    mat4 colorTransform = mat4();

    // Region that will be cleared to (0, 0, 0, 0) prior to rendering.

    // clearRegion will first be transformed by globalTransform so that it will

    // be in the same coordinate space as the rendered layers.

    Region clearRegion;

    Region clearRegion = Region::INVALID_REGION;

};

} // namespace renderengine

    // Buffer containing the image that we will render.

    // If buffer == nullptr, then the rest of the fields in this struct will be

    // ignored.

    sp<GraphicBuffer> buffer;

    sp<GraphicBuffer> buffer = nullptr;

    // Texture identifier to bind the external texture to.

    // TODO(alecmouri): This is GL-specific...make the type backend-agnostic.

    uint32_t textureName;

    uint32_t textureName = 0;

    // Whether to use filtering when rendering the texture.

    bool useTextureFiltering;

    bool useTextureFiltering = false;

    // Transform matrix to apply to texture coordinates.

    mat4 textureTransform;

    mat4 textureTransform = mat4();

    // Wheteher to use pre-multiplied alpha

    bool usePremultipliedAlpha;

    bool usePremultipliedAlpha = true;

    // HDR color-space setting for Y410.

    bool isY410BT2020;

    bool isY410BT2020 = false;

};

// Metadata describing the layer geometry.

struct Geometry {

    // Boundaries of the layer.

    FloatRect boundaries;

    FloatRect boundaries = FloatRect();

    // Transform matrix to apply to mesh coordinates.

    mat4 positionTransform;

    mat4 positionTransform = mat4();

};

// Descriptor of the source pixels for this layer.

struct PixelSource {

    // Source buffer

    Buffer buffer;

    Buffer buffer = Buffer();

    // The solid color with which to fill the layer.

    // This should only be populated if we don't render from an application

    // buffer.

    half3 solidColor;

    half3 solidColor = half3(0.0f, 0.0f, 0.0f);

};

// The settings that RenderEngine requires for correctly rendering a Layer.

struct LayerSettings {

    // Geometry information

    Geometry geometry;

    Geometry geometry = Geometry();

    // Source pixels for this layer.

    PixelSource source;

    PixelSource source = PixelSource();

    // Alpha option to apply to the source pixels

    half alpha;

    half alpha = half(0.0);

    // Color space describing how the source pixels should be interpreted.

    ui::Dataspace sourceDataspace;

    ui::Dataspace sourceDataspace = ui::Dataspace::UNKNOWN;

};

} // namespace renderengine

    return *this;

}

Rect& Rect::inset(int32_t left, int32_t top, int32_t right, int32_t bottom) {

    this->left += left;

    this->top += top;

    this->right -= right;

    this->bottom -= bottom;

Rect& Rect::inset(int32_t _left, int32_t _top, int32_t _right, int32_t _bottom) {

    this->left += _left;

    this->top += _top;

    this->right -= _right;

    this->bottom -= _bottom;

    return *this;

}

    /**

     * Insets the rectangle on all sides specified by the insets.

     */

    Rect& inset(int32_t left, int32_t top, int32_t right, int32_t bottom);

    Rect& inset(int32_t _left, int32_t _top, int32_t _right, int32_t _bottom);

    bool intersect(const Rect& with, Rect* result) const;

    "buffer_hub_base.cpp",

    "buffer_hub_rpc.cpp",

    "consumer_buffer.cpp",

    "buffer_client_impl.cpp",

    "ion_buffer.cpp",

    "producer_buffer.cpp",

]

sharedLibraries = [

    "libbase",

    "libbinder",

    "libcutils",

    "libhardware",

    "liblog",