Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cab54c46 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic "sf_display_proto" into sc-v2-dev 

* changes:
  [DO NOT MERGE] Sync flicker from master to sc-v2
  Add display proto info
parents d0abcc68 1388106f

services/surfaceflinger/Layer.cpp

+5 −5
Original line number Diff line number Diff line
@@ -2020,7 +2020,7 @@ void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags, 
        if (buffer != nullptr) {

            LayerProtoHelper::writeToProto(buffer,

                                           [&]() { return layerInfo->mutable_active_buffer(); });

            LayerProtoHelper::writeToProto(ui::Transform(getBufferTransform()),

            LayerProtoHelper::writeToProtoDeprecated(ui::Transform(getBufferTransform()),

                                                     layerInfo->mutable_buffer_transform());

        }

        layerInfo->set_invalidate(contentDirty);
@@ -2035,7 +2035,7 @@ void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags, 
        layerInfo->set_corner_radius(getRoundedCornerState().radius);

        layerInfo->set_background_blur_radius(getBackgroundBlurRadius());

        layerInfo->set_is_trusted_overlay(isTrustedOverlay());

        LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());

        LayerProtoHelper::writeToProtoDeprecated(transform, layerInfo->mutable_transform());

        LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),

                                               [&]() { return layerInfo->mutable_position(); });

        LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
@@ -2110,7 +2110,7 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet 
                                       [&]() { return layerInfo->mutable_requested_color(); });

        layerInfo->set_flags(state.flags);



        LayerProtoHelper::writeToProto(requestedTransform,

        LayerProtoHelper::writeToProtoDeprecated(requestedTransform,

                                                 layerInfo->mutable_requested_transform());



        auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();

services/surfaceflinger/LayerProtoHelper.cpp

+19 −3
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ void LayerProtoHelper::writeToProto(const half4 color, std::function<ColorProto* 
    }

}



void LayerProtoHelper::writeToProto(const ui::Transform& transform,

void LayerProtoHelper::writeToProtoDeprecated(const ui::Transform& transform,

                                              TransformProto* transformProto) {

    const uint32_t type = transform.getType() | (transform.getOrientation() << 8);

    transformProto->set_type(type);
@@ -114,6 +114,22 @@ void LayerProtoHelper::writeToProto(const ui::Transform& transform, 
    }

}



void LayerProtoHelper::writeTransformToProto(const ui::Transform& transform,

                                             TransformProto* transformProto) {

    const uint32_t type = transform.getType() | (transform.getOrientation() << 8);

    transformProto->set_type(type);



    // Rotations that are 90/180/270 have their own type so the transform matrix can be

    // reconstructed later. All other rotation have the type UNKNOWN so we need to save the

    // transform values in that case.

    if (type & (ui::Transform::SCALE | ui::Transform::UNKNOWN)) {

        transformProto->set_dsdx(transform.dsdx());

        transformProto->set_dtdx(transform.dtdx());

        transformProto->set_dtdy(transform.dtdy());

        transformProto->set_dsdy(transform.dsdy());

    }

}



void LayerProtoHelper::writeToProto(const sp<GraphicBuffer>& buffer,

                                    std::function<ActiveBufferProto*()> getActiveBufferProto) {

    if (buffer->getWidth() != 0 || buffer->getHeight() != 0 || buffer->getStride() != 0 ||
@@ -154,7 +170,7 @@ void LayerProtoHelper::writeToProto( 
    proto->set_has_wallpaper(inputInfo.hasWallpaper);



    proto->set_global_scale_factor(inputInfo.globalScaleFactor);

    LayerProtoHelper::writeToProto(inputInfo.transform, proto->mutable_transform());

    LayerProtoHelper::writeToProtoDeprecated(inputInfo.transform, proto->mutable_transform());

    proto->set_replace_touchable_region_with_crop(inputInfo.replaceTouchableRegionWithCrop);

    auto cropLayer = touchableRegionBounds.promote();

    if (cropLayer != nullptr) {

services/surfaceflinger/LayerProtoHelper.h

+6 −1
Original line number Diff line number Diff line
@@ -37,7 +37,12 @@ public: 
                             std::function<FloatRectProto*()> getFloatRectProto);

    static void writeToProto(const Region& region, std::function<RegionProto*()> getRegionProto);

    static void writeToProto(const half4 color, std::function<ColorProto*()> getColorProto);

    static void writeToProto(const ui::Transform& transform, TransformProto* transformProto);

    // This writeToProto for transform is incorrect, but due to backwards compatibility, we can't

    // update Layers to use it. Use writeTransformToProto for any new transform proto data.

    static void writeToProtoDeprecated(const ui::Transform& transform,

                                       TransformProto* transformProto);

    static void writeTransformToProto(const ui::Transform& transform,

                                      TransformProto* transformProto);

    static void writeToProto(const sp<GraphicBuffer>& buffer,

                             std::function<ActiveBufferProto*()> getActiveBufferProto);

    static void writeToProto(const gui::WindowInfo& inputInfo,

services/surfaceflinger/SurfaceFlinger.cpp

+24 −2
Original line number Diff line number Diff line
@@ -114,6 +114,7 @@ 
#include "FrameTracer/FrameTracer.h"

#include "HdrLayerInfoReporter.h"

#include "Layer.h"

#include "LayerProtoHelper.h"

#include "LayerRenderArea.h"

#include "LayerVector.h"

#include "MonitoredProducer.h"
@@ -4660,9 +4661,14 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) { 
        }



        if (dumpLayers) {

            const LayersProto layersProto = dumpProtoFromMainThread();

            LayersTraceFileProto traceFileProto = SurfaceTracing::createLayersTraceFileProto();

            LayersTraceProto* layersTrace = traceFileProto.add_entry();

            LayersProto layersProto = dumpProtoFromMainThread();

            layersTrace->mutable_layers()->Swap(&layersProto);

            dumpDisplayProto(*layersTrace);



            if (asProto) {

                result.append(layersProto.SerializeAsString());

                result.append(traceFileProto.SerializeAsString());

            } else {

                // Dump info that we need to access from the main thread

                const auto layerTree = LayerProtoParser::generateLayerTree(layersProto);
@@ -4934,6 +4940,22 @@ LayersProto SurfaceFlinger::dumpDrawingStateProto(uint32_t traceFlags) const { 
    return layersProto;

}



void SurfaceFlinger::dumpDisplayProto(LayersTraceProto& layersTraceProto) const {

    for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {

        DisplayProto* displayProto = layersTraceProto.add_displays();

        displayProto->set_id(display->getId().value);

        displayProto->set_name(display->getDisplayName());

        displayProto->set_layer_stack(display->getLayerStack());

        LayerProtoHelper::writeSizeToProto(display->getWidth(), display->getHeight(),

                                           [&]() { return displayProto->mutable_size(); });

        LayerProtoHelper::writeToProto(display->getLayerStackSpaceRect(), [&]() {

            return displayProto->mutable_layer_stack_space_rect();

        });

        LayerProtoHelper::writeTransformToProto(display->getTransform(),

                                                displayProto->mutable_transform());

    }

}



void SurfaceFlinger::dumpHwc(std::string& result) const {

    getHwComposer().dump(result);

}

services/surfaceflinger/SurfaceFlinger.h

+2 −0
Original line number Diff line number Diff line
@@ -1169,6 +1169,8 @@ private: 
    LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;

    void dumpOffscreenLayersProto(LayersProto& layersProto,

                                  uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;

    void dumpDisplayProto(LayersTraceProto& layersTraceProto) const;



    // Dumps state from HW Composer

    void dumpHwc(std::string& result) const;

    LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)