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
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index daef7c6..2c73b53 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -2042,26 +2042,26 @@
}
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 @@
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 @@
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 @@
(*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 @@
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;
diff --git a/services/surfaceflinger/LayerProtoHelper.cpp b/services/surfaceflinger/LayerProtoHelper.cpp
index 3289e8f..02383a6 100644
--- a/services/surfaceflinger/LayerProtoHelper.cpp
+++ b/services/surfaceflinger/LayerProtoHelper.cpp
@@ -18,53 +18,106 @@
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>(®ion);
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) {
- rectProto->set_left(rect.left);
- rectProto->set_top(rect.top);
- rectProto->set_bottom(rect.bottom);
- rectProto->set_right(rect.right);
+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) {
- 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,
+ 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) {
- colorProto->set_r(color.r);
- colorProto->set_g(color.g);
- colorProto->set_b(color.b);
- colorProto->set_a(color.a);
+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) {
- transformProto->set_dsdx(transform[0][0]);
- transformProto->set_dtdx(transform[0][1]);
- transformProto->set_dsdy(transform[1][0]);
- transformProto->set_dtdy(transform[1][1]);
+ 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) {
- activeBufferProto->set_width(buffer->getWidth());
- activeBufferProto->set_height(buffer->getHeight());
- activeBufferProto->set_stride(buffer->getStride());
- activeBufferProto->set_format(buffer->format);
+ 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
diff --git a/services/surfaceflinger/LayerProtoHelper.h b/services/surfaceflinger/LayerProtoHelper.h
index 6df5aea..dca9a5e 100644
--- a/services/surfaceflinger/LayerProtoHelper.h
+++ b/services/surfaceflinger/LayerProtoHelper.h
@@ -26,12 +26,18 @@
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
diff --git a/services/surfaceflinger/layerproto/layers.proto b/services/surfaceflinger/layerproto/layers.proto
index faf0c54..a0fb0a0 100644
--- a/services/surfaceflinger/layerproto/layers.proto
+++ b/services/surfaceflinger/layerproto/layers.proto
@@ -113,6 +113,7 @@
float dtdx = 2;
float dsdy = 3;
float dtdy = 4;
+ int32 type = 5;
}
message RegionProto {