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

Commit 114998a8 authored by Nataniel Borges's avatar Nataniel Borges Committed by Android (Google) Code Review
Browse files

Merge "Don't store empty objects on SF traces"

parents efff0f80 797b0e4f

services/surfaceflinger/Layer.cpp

+25 −21
Original line number Diff line number Diff line
@@ -2040,26 +2040,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));
@@ -2069,8 +2069,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());
@@ -2092,7 +2093,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());

    }
@@ -2116,9 +2118,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) {
@@ -2132,10 +2136,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 {