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

Commit 797b0e4f authored by Nataniel Borges's avatar Nataniel Borges
Browse files

Don't store empty objects on SF traces 

Proto3 doesn't store default values for object, however, it stored the
object start-end tags if an empty object was created.

Do not create objects when they are empty

Test: Flash a device. Record SF trace. Open them in the new winscope
version with "display defaults" unchecked. Check if there are no empty
objects

Change-Id: I3f48047e43e9c62c572d5b83e63a0f96527ef146
parent 705fad86

services/surfaceflinger/Layer.cpp

+25 −21
Original line number Diff line number Diff line
@@ -2042,26 +2042,26 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
    }



    LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,

                                   layerInfo->mutable_transparent_region());

    LayerProtoHelper::writeToProto(visibleRegion, layerInfo->mutable_visible_region());

    LayerProtoHelper::writeToProto(surfaceDamageRegion, layerInfo->mutable_damage_region());

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

    LayerProtoHelper::writeToProto(visibleRegion,

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

    LayerProtoHelper::writeToProto(surfaceDamageRegion,

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



    layerInfo->set_layer_stack(getLayerStack());

    layerInfo->set_z(state.z);



    PositionProto* position = layerInfo->mutable_position();

    position->set_x(transform.tx());

    position->set_y(transform.ty());

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

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



    PositionProto* requestedPosition = layerInfo->mutable_requested_position();

    requestedPosition->set_x(requestedTransform.tx());

    requestedPosition->set_y(requestedTransform.ty());

    LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(), [&]() {

        return layerInfo->mutable_requested_position();

    });



    SizeProto* size = layerInfo->mutable_size();

    size->set_w(state.active_legacy.w);

    size->set_h(state.active_legacy.h);

    LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h,

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



    LayerProtoHelper::writeToProto(state.crop_legacy, layerInfo->mutable_crop());

    LayerProtoHelper::writeToProto(state.crop_legacy, [&]() { return layerInfo->mutable_crop(); });

    layerInfo->set_corner_radius(getRoundedCornerState().radius);



    layerInfo->set_is_opaque(isOpaque(state));
@@ -2071,8 +2071,9 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
    layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));



    layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));

    LayerProtoHelper::writeToProto(getColor(), layerInfo->mutable_color());

    LayerProtoHelper::writeToProto(state.color, layerInfo->mutable_requested_color());

    LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });

    LayerProtoHelper::writeToProto(state.color,

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

    layerInfo->set_flags(state.flags);



    LayerProtoHelper::writeToProto(transform, layerInfo->mutable_transform());
@@ -2094,7 +2095,8 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 


    auto buffer = mActiveBuffer;

    if (buffer != nullptr) {

        LayerProtoHelper::writeToProto(buffer, layerInfo->mutable_active_buffer());

        LayerProtoHelper::writeToProto(buffer,

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

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

                                       layerInfo->mutable_buffer_transform());

    }
@@ -2118,9 +2120,11 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) 
        (*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());

    }

    LayerProtoHelper::writeToProto(mEffectiveTransform, layerInfo->mutable_effective_transform());

    LayerProtoHelper::writeToProto(mSourceBounds, layerInfo->mutable_source_bounds());

    LayerProtoHelper::writeToProto(mScreenBounds, layerInfo->mutable_screen_bounds());

    LayerProtoHelper::writeToProto(mBounds, layerInfo->mutable_bounds());

    LayerProtoHelper::writeToProto(mSourceBounds,

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

    LayerProtoHelper::writeToProto(mScreenBounds,

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

    LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });

}



void Layer::writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice) {
@@ -2134,10 +2138,10 @@ void Layer::writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& display 
    const auto& compositionState = outputLayer->getState();



    const Rect& frame = compositionState.displayFrame;

    LayerProtoHelper::writeToProto(frame, layerInfo->mutable_hwc_frame());

    LayerProtoHelper::writeToProto(frame, [&]() { return layerInfo->mutable_hwc_frame(); });



    const FloatRect& crop = compositionState.sourceCrop;

    LayerProtoHelper::writeToProto(crop, layerInfo->mutable_hwc_crop());

    LayerProtoHelper::writeToProto(crop, [&]() { return layerInfo->mutable_hwc_crop(); });



    const int32_t transform =

            getCompositionLayer() ? static_cast<int32_t>(compositionState.bufferTransform) : 0;

services/surfaceflinger/LayerProtoHelper.cpp

+80 −27
Original line number Diff line number Diff line
@@ -18,54 +18,107 @@ 


namespace android {

namespace surfaceflinger {

void LayerProtoHelper::writeToProto(const Region& region, RegionProto* regionProto) {



void LayerProtoHelper::writePositionToProto(const float x, const float y,

                                            std::function<PositionProto*()> getPositionProto) {

    if (x != 0 || y != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        PositionProto* position = getPositionProto();

        position->set_x(x);

        position->set_y(y);

    }

}



void LayerProtoHelper::writeSizeToProto(const uint32_t w, const uint32_t h,

                                        std::function<SizeProto*()> getSizeProto) {

    if (w != 0 || h != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        SizeProto* size = getSizeProto();

        size->set_w(w);

        size->set_h(h);

    }

}



void LayerProtoHelper::writeToProto(const Region& region,

                                    std::function<RegionProto*()> getRegionProto) {

    if (region.isEmpty()) {

        return;

    }



    Region::const_iterator head = region.begin();

    Region::const_iterator const tail = region.end();

    // Use a lambda do avoid writing the object header when the object is empty

    RegionProto* regionProto = getRegionProto();

    uint64_t address = reinterpret_cast<uint64_t>(&region);

    regionProto->set_id(address);

    while (head != tail) {

        RectProto* rectProto = regionProto->add_rect();

        writeToProto(*head, rectProto);

        std::function<RectProto*()> getProtoRect = [&]() { return regionProto->add_rect(); };

        writeToProto(*head, getProtoRect);

        head++;

    }

}



void LayerProtoHelper::writeToProto(const Rect& rect, RectProto* rectProto) {

void LayerProtoHelper::writeToProto(const Rect& rect, std::function<RectProto*()> getRectProto) {

    if (rect.left != 0 || rect.right != 0 || rect.top != 0 || rect.bottom != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        RectProto* rectProto = getRectProto();

        rectProto->set_left(rect.left);

        rectProto->set_top(rect.top);

        rectProto->set_bottom(rect.bottom);

        rectProto->set_right(rect.right);

    }

}



void LayerProtoHelper::writeToProto(const FloatRect& rect, FloatRectProto* rectProto) {

void LayerProtoHelper::writeToProto(const FloatRect& rect,

                                    std::function<FloatRectProto*()> getFloatRectProto) {

    if (rect.left != 0 || rect.right != 0 || rect.top != 0 || rect.bottom != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        FloatRectProto* rectProto = getFloatRectProto();

        rectProto->set_left(rect.left);

        rectProto->set_top(rect.top);

        rectProto->set_bottom(rect.bottom);

        rectProto->set_right(rect.right);

    }

}



void LayerProtoHelper::writeToProto(const half4 color, ColorProto* colorProto) {

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

    if (color.r != 0 || color.g != 0 || color.b != 0 || color.a != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        ColorProto* colorProto = getColorProto();

        colorProto->set_r(color.r);

        colorProto->set_g(color.g);

        colorProto->set_b(color.b);

        colorProto->set_a(color.a);

    }

}



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

                                    TransformProto* transformProto) {

    const uint32_t type = transform.getType();

    transformProto->set_type(type);



    if (type &

        (ui::Transform::SCALE | ui::Transform::ROTATE | ui::Transform::TRANSLATE |

         ui::Transform::UNKNOWN)) {

        transformProto->set_dsdx(transform[0][0]);

        transformProto->set_dtdx(transform[0][1]);

        transformProto->set_dsdy(transform[1][0]);

        transformProto->set_dtdy(transform[1][1]);

    }

}



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

                                    ActiveBufferProto* activeBufferProto) {

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

    if (buffer->getWidth() != 0 || buffer->getHeight() != 0 || buffer->getStride() != 0 ||

        buffer->format != 0) {

        // Use a lambda do avoid writing the object header when the object is empty

        ActiveBufferProto* activeBufferProto = getActiveBufferProto();

        activeBufferProto->set_width(buffer->getWidth());

        activeBufferProto->set_height(buffer->getHeight());

        activeBufferProto->set_stride(buffer->getStride());

        activeBufferProto->set_format(buffer->format);

    }

}



} // namespace surfaceflinger

} // namespace android

services/surfaceflinger/LayerProtoHelper.h

+11 −5
Original line number Diff line number Diff line
@@ -26,12 +26,18 @@ namespace android { 
namespace surfaceflinger {

class LayerProtoHelper {

public:

    static void writeToProto(const Rect& rect, RectProto* rectProto);

    static void writeToProto(const FloatRect& rect, FloatRectProto* rectProto);

    static void writeToProto(const Region& region, RegionProto* regionProto);

    static void writeToProto(const half4 color, ColorProto* colorProto);

    static void writePositionToProto(const float x, const float y,

                                     std::function<PositionProto*()> getPositionProto);

    static void writeSizeToProto(const uint32_t w, const uint32_t h,

                                 std::function<SizeProto*()> getSizeProto);

    static void writeToProto(const Rect& rect, std::function<RectProto*()> getRectProto);

    static void writeToProto(const FloatRect& rect,

                             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);

    static void writeToProto(const sp<GraphicBuffer>& buffer, ActiveBufferProto* activeBufferProto);

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

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

};



} // namespace surfaceflinger

services/surfaceflinger/layerproto/layers.proto

+1 −0
Original line number Diff line number Diff line
@@ -113,6 +113,7 @@ message TransformProto { 
  float dtdx = 2;

  float dsdy = 3;

  float dtdy = 4;

  int32 type = 5;

}



message RegionProto {