Merge "Refactored mediametrics_service_fuzzer" into main am: f9e0df6c53 am: b7b6291fea (9d1d8d0c) · Commits · e / os / android_frameworks_av

services/mediametrics/fuzzer/mediametrics_service_fuzzer.cpp

+183 −269

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@
	*****************************************************************************		*****************************************************************************
	* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore		* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
	*/		*/
			#include <binder/IPCThreadState.h>
	#include <fuzzer/FuzzedDataProvider.h>		#include <fuzzer/FuzzedDataProvider.h>
	#include <media/MediaMetricsItem.h>		#include <media/MediaMetricsItem.h>
	#include <mediametricsservice/AudioTypes.h>		#include <mediametricsservice/AudioTypes.h>
	@@ -26,210 +27,158 @@
	#include <string.h>		#include <string.h>
	#include <utils/Log.h>		#include <utils/Log.h>
	#include <algorithm>		#include <algorithm>
			#include <set>

	using namespace android;		using namespace android;
			static constexpr size_t STATSD_LOG_LINES_MAX = 48;
			static unsigned long long kPackedCallingUid = (unsigned long long)AID_SYSTEM << 32;
			constexpr int8_t kMaxBytes = 100;
			constexpr int8_t kMinBytes = 0;
			constexpr size_t kMaxItemLength = 16;

	// low water mark		// low water mark
	constexpr size_t kLogItemsLowWater = 1;		constexpr size_t kLogItemsLowWater = 1;
	// high water mark		// high water mark
	constexpr size_t kLogItemsHighWater = 2;		constexpr size_t kLogItemsHighWater = 2;
	constexpr size_t kMaxItemLength = 16;
	constexpr size_t kMaxApis = 64;		/*
			* Concatenating strings to generate keys in such a way that the
			* lambda function inside AudioAnalytics() added in the 'mAction' object is covered
			*/

			std::string keyMediaValues[] = {
			"metrics.manager",
			"mediadrm",
			"audio.device.a2dp",
			AMEDIAMETRICS_KEY_AUDIO_MIDI,
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_SPATIALIZER "*",
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_THREAD "*",
			AMEDIAMETRICS_KEY_AUDIO_FLINGER,
			AMEDIAMETRICS_KEY_AUDIO_POLICY,
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_TRACK "*",
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_RECORD "*",
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_STREAM "*",
			AMEDIAMETRICS_KEY_PREFIX_AUDIO_DEVICE
			"postBluetoothA2dpDeviceConnectionStateSuppressNoisyIntent",
			};

			std::string keyMediaAction[] = {
			"createAudioPatch",
			"connected",
			AMEDIAMETRICS_PROP_EVENT_VALUE_CREATE,
			AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT,
			AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR,
			AMEDIAMETRICS_PROP_EVENT_VALUE_ENDAAUDIOSTREAM,
			AMEDIAMETRICS_PROP_EVENT_VALUE_DEVICECLOSED,
			AMEDIAMETRICS_PROP_EVENT_VALUE_SETVOICEVOLUME,
			AMEDIAMETRICS_PROP_EVENT_VALUE_SETMODE,
			AMEDIAMETRICS_PROP_EVENT_VALUE_ENDAUDIOINTERVALGROUP,
			};

	class MediaMetricsServiceFuzzer {		class MediaMetricsServiceFuzzer {
	public:		public:
	void invokeStartsWith(const uint8_t *data, size_t size);		MediaMetricsServiceFuzzer(const uint8_t* data, size_t size) : mFdp(data, size){};
	void invokeInstantiate(const uint8_t *data, size_t size);		void process();
	void invokePackageInstallerCheck(const uint8_t *data, size_t size);		void invokeStartsWith();
	void invokeItemManipulation(const uint8_t *data, size_t size);		void invokeInstantiate();
	void invokeItemExpansion(const uint8_t *data, size_t size);		void invokePackageInstallerCheck();
	void invokeTimeMachineStorage(const uint8_t *data, size_t size);		void invokeTimeMachineStorage();
	void invokeTransactionLog(const uint8_t *data, size_t size);		void invokeTransactionLog();
	void invokeAnalyticsAction(const uint8_t *data, size_t size);		void invokeAnalyticsAction();
	void invokeAudioAnalytics(const uint8_t *data, size_t size);		void invokeAudioAnalytics();
	void invokeTimedAction(const uint8_t *data, size_t size);		void invokeTimedAction();
	void process(const uint8_t *data, size_t size);		void setKeyValues(std::shared_ptr<mediametrics::Item>& item, std::string keyValue);
			std::shared_ptr<mediametrics::Item> CreateItem();
			sp<MediaMetricsService> mMediaMetricsService;
			FuzzedDataProvider mFdp;
	std::atomic_int mValue = 0;		std::atomic_int mValue = 0;
	};		};

	void MediaMetricsServiceFuzzer::invokeStartsWith(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::setKeyValues(std::shared_ptr<mediametrics::Item>& item,
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);		std::string keyValue) {
	while (fdp.remaining_bytes()) {		auto invokeActionAPIs = mFdp.PickValueInArray<const std::function<void()>>({
	android::mediametrics::startsWith(fdp.ConsumeRandomLengthString(),		[&]() { item->setInt32(keyValue.c_str(), mFdp.ConsumeIntegral<int32_t>()); },
	fdp.ConsumeRandomLengthString());		[&]() { item->addInt32(keyValue.c_str(), mFdp.ConsumeIntegral<int32_t>()); },
	}		[&]() { item->setInt64(keyValue.c_str(), mFdp.ConsumeIntegral<int64_t>()); },
	}		[&]() { item->addInt64(keyValue.c_str(), mFdp.ConsumeIntegral<int64_t>()); },
			[&]() { item->setDouble(keyValue.c_str(), mFdp.ConsumeFloatingPoint<double>()); },
	void MediaMetricsServiceFuzzer::invokeInstantiate(const uint8_t *data, size_t size) {		[&]() { item->addDouble(keyValue.c_str(), mFdp.ConsumeFloatingPoint<double>()); },
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);		[&]() { item->setTimestamp(mFdp.ConsumeIntegral<int64_t>()); },
	sp mediaMetricsService = new MediaMetricsService();		[&]() {
			std::string value = mFdp.ConsumeBool()
	while (fdp.remaining_bytes()) {		? mFdp.ConsumeRandomLengthString(kMaxBytes)
	std::unique_ptr<mediametrics::Item> random_key(		: mFdp.PickValueInArray<std::string>(keyMediaAction);
	mediametrics::Item::create(fdp.ConsumeRandomLengthString()));		item->setCString(keyValue.c_str(), value.c_str());
	mediaMetricsService->submit(random_key.get());		},
	random_key->setInt32(fdp.ConsumeRandomLengthString().c_str(),		[&]() {
	fdp.ConsumeIntegral<int32_t>());		item->setRate(keyValue.c_str(), mFdp.ConsumeIntegral<int64_t>(),
	mediaMetricsService->submit(random_key.get());		mFdp.ConsumeIntegral<int64_t>());
			},
	std::unique_ptr<mediametrics::Item> audiotrack_key(		[&]() {
	mediametrics::Item::create("audiotrack"));		mediametrics::LogItem<1> itemTemp(mFdp.ConsumeRandomLengthString(kMaxBytes));
	mediaMetricsService->submit(audiotrack_key.get());		itemTemp.setPid(mFdp.ConsumeIntegral<int16_t>())
	audiotrack_key->addInt32(fdp.ConsumeRandomLengthString().c_str(),		.setUid(mFdp.ConsumeIntegral<int16_t>());
	fdp.ConsumeIntegral<int32_t>());
	mediaMetricsService->submit(audiotrack_key.get());		int32_t i = mFdp.ConsumeIntegral<int32_t>();
	}		itemTemp.set(std::to_string(i).c_str(), (int32_t)i);
	}		itemTemp.updateHeader();
			(void)item->readFromByteString(itemTemp.getBuffer(), itemTemp.getLength());
	void MediaMetricsServiceFuzzer::invokePackageInstallerCheck(const uint8_t *data, size_t size) {		},
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);
	while (fdp.remaining_bytes()) {		});
	MediaMetricsService::useUidForPackage(fdp.ConsumeRandomLengthString().c_str(),		invokeActionAPIs();
	fdp.ConsumeRandomLengthString().c_str());		}
	}
	}		std::shared_ptr<mediametrics::Item> MediaMetricsServiceFuzzer::CreateItem() {
			std::string key;
	void MediaMetricsServiceFuzzer::invokeItemManipulation(const uint8_t *data, size_t size) {		if (mFdp.ConsumeBool()) {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);		key = mFdp.ConsumeRandomLengthString(kMaxItemLength);
			} else {
	mediametrics::Item item(fdp.ConsumeRandomLengthString().c_str());		key = mFdp.PickValueInArray<std::string>(keyMediaValues);
	while (fdp.remaining_bytes()) {		}
	const uint8_t action = fdp.ConsumeIntegralInRange<uint8_t>(0, 16);
	const std::string key = fdp.ConsumeRandomLengthString();		std::shared_ptr<mediametrics::Item> item = std::make_shared<mediametrics::Item>(key.c_str());
	if (fdp.remaining_bytes() < 1 \|\| key.length() < 1) {		size_t numKeys = mFdp.ConsumeIntegralInRange<size_t>(kMinBytes, kMaxBytes);
	break;		std::set<std::string> keySet;
	}		for (size_t i = 0; i < numKeys; ++i) {
	switch (action) {		std::string keyValue;
	case 0: {		if (mFdp.ConsumeBool()) {
	item.setInt32(key.c_str(), fdp.ConsumeIntegral<int32_t>());		keyValue = mFdp.ConsumeRandomLengthString(kMaxBytes);
	break;		} else {
	}		keyValue = mFdp.PickValueInArray<std::string>(
	case 1: {		{AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_STATE, "logSessionIkeyd"});
	item.addInt32(key.c_str(), fdp.ConsumeIntegral<int32_t>());		}
	break;		if (keySet.find(keyValue) == keySet.end()) {
	}		setKeyValues(item, keyValue);
	case 2: {		keySet.insert(keyValue);
	int32_t i32 = 0;		}
	item.getInt32(key.c_str(), &i32);		}
	break;		return item;
	}		}
	case 3: {
	item.setInt64(key.c_str(), fdp.ConsumeIntegral<int64_t>());		void MediaMetricsServiceFuzzer::invokeStartsWith() {
	break;		android::mediametrics::startsWith(mFdp.ConsumeRandomLengthString(kMaxBytes),
	}		mFdp.ConsumeRandomLengthString(kMaxBytes));
	case 4: {		}
	item.addInt64(key.c_str(), fdp.ConsumeIntegral<int64_t>());
	break;		void MediaMetricsServiceFuzzer::invokeInstantiate() {
	}		auto item = CreateItem();
	case 5: {		mMediaMetricsService->submit(item.get());
	int64_t i64 = 0;		}
	item.getInt64(key.c_str(), &i64);
	break;		void MediaMetricsServiceFuzzer::invokePackageInstallerCheck() {
	}		MediaMetricsService::useUidForPackage(mFdp.ConsumeRandomLengthString(kMaxBytes).c_str(),
	case 6: {		mFdp.ConsumeRandomLengthString(kMaxBytes).c_str());
	item.setDouble(key.c_str(), fdp.ConsumeFloatingPoint<double>());		}
	break;
	}		void MediaMetricsServiceFuzzer::invokeTimeMachineStorage() {
	case 7: {		auto item = CreateItem();
	item.addDouble(key.c_str(), fdp.ConsumeFloatingPoint<double>());		int32_t i32 = mFdp.ConsumeIntegral<int32_t>();
	break;		int64_t i64 = mFdp.ConsumeIntegral<int64_t>();
	}		double d = mFdp.ConsumeFloatingPoint<double>();
	case 8: {		std::string str = mFdp.ConsumeRandomLengthString(kMaxBytes);
	double d = 0;		std::pair<int64_t, int64_t> pair(mFdp.ConsumeIntegral<int64_t>(),
	item.getDouble(key.c_str(), &d);		mFdp.ConsumeIntegral<int64_t>());
	break;
	}
	case 9: {
	item.setCString(key.c_str(), fdp.ConsumeRandomLengthString().c_str());
	break;
	}
	case 10: {
	char *s = nullptr;
	item.getCString(key.c_str(), &s);
	if (s) free(s);
	break;
	}
	case 11: {
	std::string s;
	item.getString(key.c_str(), &s);
	break;
	}
	case 12: {
	item.setRate(key.c_str(), fdp.ConsumeIntegral<int64_t>(),
	fdp.ConsumeIntegral<int64_t>());
	break;
	}
	case 13: {
	int64_t b = 0, h = 0;
	double d = 0;
	item.getRate(key.c_str(), &b, &h, &d);
	break;
	}
	case 14: {
	(void)item.filter(key.c_str());
	break;
	}
	case 15: {
	const char *arr[1] = {""};
	arr[0] = const_cast<char *>(key.c_str());
	(void)item.filterNot(1, arr);
	break;
	}
	case 16: {
	(void)item.toString().c_str();
	break;
	}
	}
	}

	Parcel p;
	mediametrics::Item item2;

	(void)item.writeToParcel(&p);
	p.setDataPosition(0); // rewind for reading
	(void)item2.readFromParcel(p);

	char *byteData = nullptr;
	size_t length = 0;
	(void)item.writeToByteString(&byteData, &length);
	(void)item2.readFromByteString(byteData, length);
	if (byteData) {
	free(byteData);
	}

	sp mediaMetricsService = new MediaMetricsService();
	mediaMetricsService->submit(&item2);
	}

	void MediaMetricsServiceFuzzer::invokeItemExpansion(const uint8_t *data, size_t size) {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);

	mediametrics::LogItem<1> item("FuzzItem");
	item.setPid(fdp.ConsumeIntegral<int16_t>()).setUid(fdp.ConsumeIntegral<int16_t>());

	while (fdp.remaining_bytes()) {
	int32_t i = fdp.ConsumeIntegral<int32_t>();
	item.set(std::to_string(i).c_str(), (int32_t)i);
	}
	item.updateHeader();

	mediametrics::Item item2;
	(void)item2.readFromByteString(item.getBuffer(), item.getLength());

	sp mediaMetricsService = new MediaMetricsService();
	mediaMetricsService->submit(&item2);
	}

	void MediaMetricsServiceFuzzer::invokeTimeMachineStorage(const uint8_t *data, size_t size) {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);

	auto item = std::make_shared<mediametrics::Item>("FuzzKey");
	int32_t i32 = fdp.ConsumeIntegral<int32_t>();
	int64_t i64 = fdp.ConsumeIntegral<int64_t>();
	double d = fdp.ConsumeFloatingPoint<double>();
	std::string str = fdp.ConsumeRandomLengthString();
	std::pair<int64_t, int64_t> pair(fdp.ConsumeIntegral<int64_t>(),
	fdp.ConsumeIntegral<int64_t>());
	(*item).set("i32", i32).set("i64", i64).set("double", d).set("string", str).set("rate", pair);		(*item).set("i32", i32).set("i64", i64).set("double", d).set("string", str).set("rate", pair);

	android::mediametrics::TimeMachine timeMachine;		android::mediametrics::TimeMachine timeMachine;
	@@ -253,65 +202,31 @@ void MediaMetricsServiceFuzzer::invokeTimeMachineStorage(const uint8_t *data, si
	timeMachine.get("Key.string", &str, -1);		timeMachine.get("Key.string", &str, -1);
	}		}

	void MediaMetricsServiceFuzzer::invokeTransactionLog(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::invokeTransactionLog() {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);		auto item = CreateItem();

	auto item = std::make_shared<mediametrics::Item>("Key1");
	(*item)
	.set("one", fdp.ConsumeIntegral<int32_t>())
	.set("two", fdp.ConsumeIntegral<int32_t>())
	.setTimestamp(fdp.ConsumeIntegral<int32_t>());

	android::mediametrics::TransactionLog transactionLog(		android::mediametrics::TransactionLog transactionLog(
	kLogItemsLowWater, kLogItemsHighWater); // keep at most 2 items		kLogItemsLowWater, kLogItemsHighWater); // keep at most 2 items
	transactionLog.size();		transactionLog.size();

	transactionLog.put(item);		transactionLog.put(item);
	transactionLog.size();

	auto item2 = std::make_shared<mediametrics::Item>("Key2");
	(*item2)
	.set("three", fdp.ConsumeIntegral<int32_t>())
	.set("[Key1]three", fdp.ConsumeIntegral<int32_t>())
	.setTimestamp(fdp.ConsumeIntegral<int32_t>());

	transactionLog.put(item2);
	transactionLog.size();

	auto item3 = std::make_shared<mediametrics::Item>("Key3");
	(*item3)
	.set("six", fdp.ConsumeIntegral<int32_t>())
	.set("[Key1]four", fdp.ConsumeIntegral<int32_t>()) // affects Key1
	.set("[Key1]five", fdp.ConsumeIntegral<int32_t>()) // affects key1
	.setTimestamp(fdp.ConsumeIntegral<int32_t>());

	transactionLog.put(item3);
	transactionLog.size();
	}		}

	void MediaMetricsServiceFuzzer::invokeAnalyticsAction(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::invokeAnalyticsAction() {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);

	mediametrics::AnalyticsActions analyticsActions;		mediametrics::AnalyticsActions analyticsActions;
	bool action = false;		bool action = false;

	while (fdp.remaining_bytes()) {
	analyticsActions.addAction(		analyticsActions.addAction(
	(fdp.ConsumeRandomLengthString() + std::string(".event")).c_str(),		(mFdp.ConsumeRandomLengthString(kMaxBytes) + std::string(".event")).c_str(),
	fdp.ConsumeRandomLengthString(),		mFdp.ConsumeRandomLengthString(kMaxBytes),
	std::make_shared<mediametrics::AnalyticsActions::Function>(		std::make_shared<mediametrics::AnalyticsActions::Function>(
	[&](const std::shared_ptr<const android::mediametrics::Item>&) {		[&](const std::shared_ptr<const android::mediametrics::Item>&) {
	action = true;		action = true;
	}));		}));
	}

	FuzzedDataProvider fdp2 = FuzzedDataProvider(data, size);
	size_t apiCount = 0;
	while (fdp2.remaining_bytes() && ++apiCount <= kMaxApis) {
	// make a test item		// make a test item
	auto item = std::make_shared<mediametrics::Item>(		auto item = CreateItem();
	fdp2.ConsumeRandomLengthString(kMaxItemLength).c_str());		(*item).set("event", mFdp.ConsumeRandomLengthString(kMaxBytes).c_str());
	(*item).set("event", fdp2.ConsumeRandomLengthString().c_str());

	// get the actions and execute them		// get the actions and execute them
	auto actions = analyticsActions.getActionsForItem(item);		auto actions = analyticsActions.getActionsForItem(item);
	@@ -319,58 +234,57 @@ void MediaMetricsServiceFuzzer::invokeAnalyticsAction(const uint8_t *data, size_
	action->operator()(item);		action->operator()(item);
	}		}
	}		}
	}

	void MediaMetricsServiceFuzzer::invokeAudioAnalytics(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::invokeAudioAnalytics() {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);		int32_t maxLogLine = mFdp.ConsumeIntegralInRange<int32_t>(0, STATSD_LOG_LINES_MAX);
	std::shared_ptr<android::mediametrics::StatsdLog> statsdLog =		std::shared_ptr<android::mediametrics::StatsdLog> statsdLog =
	std::make_shared<android::mediametrics::StatsdLog>(10);		std::make_shared<android::mediametrics::StatsdLog>(maxLogLine);
	android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};		android::mediametrics::AudioAnalytics audioAnalytics{statsdLog};

	while (fdp.remaining_bytes()) {		auto item = CreateItem();
	auto item = std::make_shared<mediametrics::Item>(fdp.ConsumeRandomLengthString().c_str());		Parcel parcel;
	int32_t transactionUid = fdp.ConsumeIntegral<int32_t>(); // arbitrary		item->writeToParcel(&parcel);
	(*item)		parcel.setDataPosition(0);
	.set(fdp.ConsumeRandomLengthString().c_str(), fdp.ConsumeIntegral<int32_t>())		if (mFdp.ConsumeBool()) {
	.set(fdp.ConsumeRandomLengthString().c_str(), fdp.ConsumeIntegral<int32_t>())		item->readFromParcel(parcel);
	.set(AMEDIAMETRICS_PROP_ALLOWUID, transactionUid)
	.setUid(transactionUid)
	.setTimestamp(fdp.ConsumeIntegral<int32_t>());
	audioAnalytics.submit(item, fdp.ConsumeBool());
	}		}
			audioAnalytics.submit(item, mFdp.ConsumeBool());
	audioAnalytics.dump(1000);
	}		}

	void MediaMetricsServiceFuzzer::invokeTimedAction(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::invokeTimedAction() {
	FuzzedDataProvider fdp = FuzzedDataProvider(data, size);
	android::mediametrics::TimedAction timedAction;		android::mediametrics::TimedAction timedAction;
			timedAction.postIn(std::chrono::seconds(mFdp.ConsumeIntegral<uint32_t>()),
	while (fdp.remaining_bytes()) {
	timedAction.postIn(std::chrono::seconds(fdp.ConsumeIntegral<int32_t>()),
	[this] { ++mValue; });		[this] { ++mValue; });
	timedAction.size();		timedAction.size();
	}		}
	}

	void MediaMetricsServiceFuzzer::process(const uint8_t *data, size_t size) {		void MediaMetricsServiceFuzzer::process() {
	invokeStartsWith(data, size);		mMediaMetricsService = sp<MediaMetricsService>::make();
	invokeInstantiate(data, size);
	invokePackageInstallerCheck(data, size);		if (mFdp.ConsumeBool()) {
	invokeItemManipulation(data, size);		IPCThreadState::self()->restoreCallingIdentity(kPackedCallingUid);
	invokeItemExpansion(data, size);		} else {
	invokeTimeMachineStorage(data, size);		IPCThreadState::self()->restoreCallingIdentity(mFdp.ConsumeIntegral<size_t>());
	invokeTransactionLog(data, size);		}
	invokeAnalyticsAction(data, size);		while (mFdp.remaining_bytes()) {
	invokeAudioAnalytics(data, size);		auto invokeAPIs = mFdp.PickValueInArray<const std::function<void()>>({
	invokeTimedAction(data, size);		[&]() { invokeStartsWith(); },
			[&]() { invokeInstantiate(); },
			[&]() { invokePackageInstallerCheck(); },
			[&]() { invokeTimeMachineStorage(); },
			[&]() { invokeTransactionLog(); },
			[&]() { invokeAudioAnalytics(); },
			[&]() { invokeTimedAction(); },
			});
			invokeAPIs();
			}
	}		}

	extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {		extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
	if (size < 1) {		if (size < 1) {
	return 0;		return 0;
	}		}
	MediaMetricsServiceFuzzer mediaMetricsServiceFuzzer;		MediaMetricsServiceFuzzer mediaMetricsServiceFuzzer(data, size);
	mediaMetricsServiceFuzzer.process(data, size);		mediaMetricsServiceFuzzer.process();
	return 0;		return 0;
	}		}