Merge "SF: Add trace section flags and InputWindowInfo to sf trace" (d2ecb31e) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/Layer.cpp

+97 −81

Original line number	Diff line number	Diff line
		@@ -1845,7 +1845,8 @@ void Layer::setInputInfo(const InputWindowInfo& info) {
		setTransactionFlags(eTransactionNeeded);
		}

		void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) {
		void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet,
		uint32_t traceFlags) {
		const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
		const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
		const State& state = useDrawing ? mDrawingState : mCurrentState;
		@@ -1853,6 +1854,7 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet)
		ui::Transform requestedTransform = state.active_legacy.transform;
		ui::Transform transform = getTransform();

		if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
		layerInfo->set_id(sequence);
		layerInfo->set_name(getName().c_str());
		layerInfo->set_type(String8(getTypeId()));
		@@ -1881,21 +1883,24 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet)
		LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),
		[&]() { return layerInfo->mutable_position(); });

		LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(), [&]() {
		LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),
		[&]() {
		return layerInfo->mutable_requested_position();
		});

		LayerProtoHelper::writeSizeToProto(state.active_legacy.w, state.active_legacy.h,
		[&]() { return layerInfo->mutable_size(); });

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

		layerInfo->set_is_opaque(isOpaque(state));
		layerInfo->set_invalidate(contentDirty);

		// XXX (b/79210409) mCurrentDataSpace is not protected
		layerInfo->set_dataspace(dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));
		layerInfo->set_dataspace(
		dataspaceDetails(static_cast<android_dataspace>(mCurrentDataSpace)));

		layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));
		LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
		@@ -1904,7 +1909,8 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet)
		layerInfo->set_flags(state.flags);

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

		auto parent = useDrawing ? mDrawingParent.promote() : mCurrentParent.promote();
		if (parent != nullptr) {
		@@ -1941,26 +1947,36 @@ void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet)
		barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);
		}
		}
		LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
		}

		if (traceFlags & SurfaceTracing::TRACE_INPUT) {
		LayerProtoHelper::writeToProto(state.inputInfo, state.touchableRegionCrop,
		[&]() { return layerInfo->mutable_input_window_info(); });
		}

		if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
		auto protoMap = layerInfo->mutable_metadata();
		for (const auto& entry : state.metadata.mMap) {
		(*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());
		}
		LayerProtoHelper::writeToProto(mEffectiveTransform, layerInfo->mutable_effective_transform());
		LayerProtoHelper::writeToProto(mEffectiveTransform,
		layerInfo->mutable_effective_transform());
		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) {
		void Layer::writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice,
		uint32_t traceFlags) {
		auto outputLayer = findOutputLayerForDisplay(displayDevice);
		if (!outputLayer) {
		return;
		}

		writeToProto(layerInfo, LayerVector::StateSet::Drawing);
		writeToProto(layerInfo, LayerVector::StateSet::Drawing, traceFlags);

		const auto& compositionState = outputLayer->getState();

services/surfaceflinger/Layer.h

+4 −3

Original line number	Diff line number	Diff line
		@@ -433,10 +433,11 @@ public:

		bool isRemovedFromCurrentState() const;

		void writeToProto(LayerProto* layerInfo,
		LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing);
		void writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet,
		uint32_t traceFlags = SurfaceTracing::TRACE_ALL);

		void writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice);
		void writeToProto(LayerProto* layerInfo, const sp<DisplayDevice>& displayDevice,
		uint32_t traceFlags = SurfaceTracing::TRACE_ALL);

		virtual Geometry getActiveGeometry(const Layer::State& s) const { return s.active_legacy; }
		virtual uint32_t getActiveWidth(const Layer::State& s) const { return s.active_legacy.w; }

services/surfaceflinger/LayerProtoHelper.cpp

+36 −0

Original line number	Diff line number	Diff line
		@@ -119,5 +119,41 @@ void LayerProtoHelper::writeToProto(const sp<GraphicBuffer>& buffer,
		}
		}

		void LayerProtoHelper::writeToProto(
		const InputWindowInfo& inputInfo, const wp<Layer>& touchableRegionBounds,
		std::function<InputWindowInfoProto*()> getInputWindowInfoProto) {
		if (inputInfo.token == nullptr) {
		return;
		}

		InputWindowInfoProto* proto = getInputWindowInfoProto();
		proto->set_layout_params_flags(inputInfo.layoutParamsFlags);
		proto->set_layout_params_type(inputInfo.layoutParamsType);

		LayerProtoHelper::writeToProto({inputInfo.frameLeft, inputInfo.frameTop, inputInfo.frameRight,
		inputInfo.frameBottom},
		[&]() { return proto->mutable_frame(); });
		LayerProtoHelper::writeToProto(inputInfo.touchableRegion,
		[&]() { return proto->mutable_touchable_region(); });

		proto->set_surface_inset(inputInfo.surfaceInset);
		proto->set_visible(inputInfo.visible);
		proto->set_can_receive_keys(inputInfo.canReceiveKeys);
		proto->set_has_focus(inputInfo.hasFocus);
		proto->set_has_wallpaper(inputInfo.hasWallpaper);

		proto->set_global_scale_factor(inputInfo.globalScaleFactor);
		proto->set_window_x_scale(inputInfo.windowXScale);
		proto->set_window_y_scale(inputInfo.windowYScale);
		proto->set_replace_touchable_region_with_crop(inputInfo.replaceTouchableRegionWithCrop);
		auto cropLayer = touchableRegionBounds.promote();
		if (cropLayer != nullptr) {
		proto->set_crop_layer_id(cropLayer->sequence);
		LayerProtoHelper::writeToProto(cropLayer->getScreenBounds(
		false /* reduceTransparentRegion */),
		[&]() { return proto->mutable_touchable_region_crop(); });
		}
		}

		} // namespace surfaceflinger
		} // namespace android

services/surfaceflinger/LayerProtoHelper.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,8 @@

		#include <layerproto/LayerProtoHeader.h>

		#include <Layer.h>
		#include <input/InputWindow.h>
		#include <math/vec4.h>
		#include <ui/GraphicBuffer.h>
		#include <ui/Rect.h>
		@@ -38,6 +40,9 @@ public:
		static void writeToProto(const ui::Transform& transform, TransformProto* transformProto);
		static void writeToProto(const sp<GraphicBuffer>& buffer,
		std::function<ActiveBufferProto*()> getActiveBufferProto);
		static void writeToProto(const InputWindowInfo& inputInfo,
		const wp<Layer>& touchableRegionBounds,
		std::function<InputWindowInfoProto*()> getInputWindowInfoProto);
		};

		} // namespace surfaceflinger

services/surfaceflinger/SurfaceFlinger.cpp

+13 −4

Original line number	Diff line number	Diff line
		@@ -4644,13 +4644,14 @@ void SurfaceFlinger::dumpWideColorInfo(std::string& result) const {
		result.append("\n");
		}

		LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet) const {
		LayersProto SurfaceFlinger::dumpProtoInfo(LayerVector::StateSet stateSet,
		uint32_t traceFlags) const {
		LayersProto layersProto;
		const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
		const State& state = useDrawing ? mDrawingState : mCurrentState;
		state.traverseInZOrder([&](Layer* layer) {
		LayerProto* layerProto = layersProto.add_layers();
		layer->writeToProto(layerProto, stateSet);
		layer->writeToProto(layerProto, stateSet, traceFlags);
		});

		return layersProto;
		@@ -4993,9 +4994,9 @@ status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
		code == IBinder::SYSPROPS_TRANSACTION) {
		return OK;
		}
		// Numbers from 1000 to 1032 are currently use for backdoors. The code
		// Numbers from 1000 to 1033 are currently used for backdoors. The code
		// in onTransact verifies that the user is root, and has access to use SF.
		if (code >= 1000 && code <= 1032) {
		if (code >= 1000 && code <= 1033) {
		ALOGV("Accessing SurfaceFlinger through backdoor code: %u", code);
		return OK;
		}
		@@ -5303,6 +5304,14 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
		mDebugEnableProtectedContent = n;
		return NO_ERROR;
		}
		// Set trace flags
		case 1033: {
		n = data.readUint32();
		ALOGD("Updating trace flags to 0x%x", n);
		mTracing.setTraceFlags(n);
		reply->writeInt32(NO_ERROR);
		return NO_ERROR;
		}
		}
		}
		return err;