gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix memory leaks in mediaanalytics

Browse Source 
This fixes > a dozen potential leaks flagged by clang's static
analyzer, and fixes the use of other nearby manual memory management.

Bug: None
Test: TreeHugger
Change-Id: I8af2523804986b278150291fb2dc7ca5af8391ee
gugelfrei
George Burgess IV 5 years ago
parent 35f148bc5a
commit 0d81443b76
8 changed files with 113 additions and 166 deletions
Show Stats Download Patch File Download Diff File

44
services/mediaanalytics/statsd_audiopolicy.cpp
Unescape View File

@ -60,14 +60,14 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
metrics_proto.set_status(status); metrics_proto.set_status(status);
} }
//string char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src"; //string char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
char *rqst_src = NULL; std::string rqst_src;
if (item->getCString("android.media.audiopolicy.rqst.src", &rqst_src)) { if (item->getString("android.media.audiopolicy.rqst.src", &rqst_src)) {
metrics_proto.set_request_source(rqst_src); metrics_proto.set_request_source(std::move(rqst_src));
} }
//string char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg"; //string char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
char *rqst_pkg = NULL; std::string rqst_pkg;
if (item->getCString("android.media.audiopolicy.rqst.pkg", &rqst_pkg)) { if (item->getString("android.media.audiopolicy.rqst.pkg", &rqst_pkg)) {
metrics_proto.set_request_package(rqst_pkg); metrics_proto.set_request_package(std::move(rqst_pkg));
} }
//int32 char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session"; //int32 char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
int32_t rqst_session = -1; int32_t rqst_session = -1;
@ -75,20 +75,20 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
metrics_proto.set_request_session(rqst_session); metrics_proto.set_request_session(rqst_session);
} }
//string char kAudioPolicyRqstDevice[] = "android.media.audiopolicy.rqst.device"; //string char kAudioPolicyRqstDevice[] = "android.media.audiopolicy.rqst.device";
char *rqst_device = NULL; std::string rqst_device;
if (item->getCString("android.media.audiopolicy.rqst.device", &rqst_device)) { if (item->getString("android.media.audiopolicy.rqst.device", &rqst_device)) {
metrics_proto.set_request_device(rqst_device); metrics_proto.set_request_device(std::move(rqst_device));
} }
//string char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src"; //string char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
char *active_src = NULL; std::string active_src;
if (item->getCString("android.media.audiopolicy.active.src", &active_src)) { if (item->getString("android.media.audiopolicy.active.src", &active_src)) {
metrics_proto.set_active_source(active_src); metrics_proto.set_active_source(std::move(active_src));
} }
//string char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg"; //string char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
char *active_pkg = NULL; std::string active_pkg;
if (item->getCString("android.media.audiopolicy.active.pkg", &active_pkg)) { if (item->getString("android.media.audiopolicy.active.pkg", &active_pkg)) {
metrics_proto.set_active_package(active_pkg); metrics_proto.set_active_package(std::move(active_pkg));
} }
//int32 char kAudioPolicyActiveSession[] = "android.media.audiopolicy.active.session"; //int32 char kAudioPolicyActiveSession[] = "android.media.audiopolicy.active.session";
int32_t active_session = -1; int32_t active_session = -1;
@ -96,9 +96,9 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
metrics_proto.set_active_session(active_session); metrics_proto.set_active_session(active_session);
} }
//string char kAudioPolicyActiveDevice[] = "android.media.audiopolicy.active.device"; //string char kAudioPolicyActiveDevice[] = "android.media.audiopolicy.active.device";
char *active_device = NULL; std::string active_device;
if (item->getCString("android.media.audiopolicy.active.device", &active_device)) { if (item->getString("android.media.audiopolicy.active.device", &active_device)) {
metrics_proto.set_active_device(active_device); metrics_proto.set_active_device(std::move(active_device));
} }
@ -119,14 +119,6 @@ bool statsd_audiopolicy(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(rqst_src);
free(rqst_pkg);
free(rqst_device);
free(active_src);
free(active_pkg);
free(active_device);
return true; return true;
} }

34
services/mediaanalytics/statsd_audiorecord.cpp
Unescape View File

@ -54,14 +54,14 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
// flesh out the protobuf we'll hand off with our data // flesh out the protobuf we'll hand off with our data
// //
char *encoding = NULL; std::string encoding;
if (item->getCString("android.media.audiorecord.encoding", &encoding)) { if (item->getString("android.media.audiorecord.encoding", &encoding)) {
metrics_proto.set_encoding(encoding); metrics_proto.set_encoding(std::move(encoding));
} }
char *source = NULL; std::string source;
if (item->getCString("android.media.audiorecord.source", &source)) { if (item->getString("android.media.audiorecord.source", &source)) {
metrics_proto.set_source(source); metrics_proto.set_source(std::move(source));
} }
int32_t latency = -1; int32_t latency = -1;
@ -101,11 +101,11 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
metrics_proto.set_error_code(errcode); metrics_proto.set_error_code(errcode);
} }
char *errfunc = NULL; std::string errfunc;
if (item->getCString("android.media.audiorecord.errfunc", &errfunc)) { if (item->getString("android.media.audiorecord.errfunc", &errfunc)) {
metrics_proto.set_error_function(errfunc); metrics_proto.set_error_function(std::move(errfunc));
} else if (item->getCString("android.media.audiorecord.lastError.at", &errfunc)) { } else if (item->getString("android.media.audiorecord.lastError.at", &errfunc)) {
metrics_proto.set_error_function(errfunc); metrics_proto.set_error_function(std::move(errfunc));
} }
// portId (int32) // portId (int32)
@ -119,9 +119,9 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
metrics_proto.set_frame_count(frameCount); metrics_proto.set_frame_count(frameCount);
} }
// attributes (string) // attributes (string)
char *attributes = NULL; std::string attributes;
if (item->getCString("android.media.audiorecord.attributes", &attributes)) { if (item->getString("android.media.audiorecord.attributes", &attributes)) {
metrics_proto.set_attributes(attributes); metrics_proto.set_attributes(std::move(attributes));
} }
// channelMask (int64) // channelMask (int64)
int64_t channelMask = -1; int64_t channelMask = -1;
@ -152,12 +152,6 @@ bool statsd_audiorecord(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(encoding);
free(source);
free(errfunc);
free(attributes);
return true; return true;
} }

58
services/mediaanalytics/statsd_audiothread.cpp
Unescape View File

@ -56,9 +56,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
// flesh out the protobuf we'll hand off with our data // flesh out the protobuf we'll hand off with our data
// //
char *mytype = NULL; std::string mytype;
if (item->getCString(MM_PREFIX "type", &mytype)) { if (item->getString(MM_PREFIX "type", &mytype)) {
metrics_proto.set_type(mytype); metrics_proto.set_type(std::move(mytype));
} }
int32_t framecount = -1; int32_t framecount = -1;
if (item->getInt32(MM_PREFIX "framecount", &framecount)) { if (item->getInt32(MM_PREFIX "framecount", &framecount)) {
@ -68,17 +68,17 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
if (item->getInt32(MM_PREFIX "samplerate", &samplerate)) { if (item->getInt32(MM_PREFIX "samplerate", &samplerate)) {
metrics_proto.set_samplerate(samplerate); metrics_proto.set_samplerate(samplerate);
} }
char *workhist = NULL; std::string workhist;
if (item->getCString(MM_PREFIX "workMs.hist", &workhist)) { if (item->getString(MM_PREFIX "workMs.hist", &workhist)) {
metrics_proto.set_work_millis_hist(workhist); metrics_proto.set_work_millis_hist(std::move(workhist));
} }
char *latencyhist = NULL; std::string latencyhist;
if (item->getCString(MM_PREFIX "latencyMs.hist", &latencyhist)) { if (item->getString(MM_PREFIX "latencyMs.hist", &latencyhist)) {
metrics_proto.set_latency_millis_hist(latencyhist); metrics_proto.set_latency_millis_hist(std::move(latencyhist));
} }
char *warmuphist = NULL; std::string warmuphist;
if (item->getCString(MM_PREFIX "warmupMs.hist", &warmuphist)) { if (item->getString(MM_PREFIX "warmupMs.hist", &warmuphist)) {
metrics_proto.set_warmup_millis_hist(warmuphist); metrics_proto.set_warmup_millis_hist(std::move(warmuphist));
} }
int64_t underruns = -1; int64_t underruns = -1;
if (item->getInt64(MM_PREFIX "underruns", &underruns)) { if (item->getInt64(MM_PREFIX "underruns", &underruns)) {
@ -108,9 +108,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
metrics_proto.set_port_id(port_id); metrics_proto.set_port_id(port_id);
} }
// item->setCString(MM_PREFIX "type", threadTypeToString(mType)); // item->setCString(MM_PREFIX "type", threadTypeToString(mType));
char *type = NULL; std::string type;
if (item->getCString(MM_PREFIX "type", &type)) { if (item->getString(MM_PREFIX "type", &type)) {
metrics_proto.set_type(type); metrics_proto.set_type(std::move(type));
} }
// item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate); // item->setInt32(MM_PREFIX "sampleRate", (int32_t)mSampleRate);
int32_t sample_rate = -1; int32_t sample_rate = -1;
@ -123,9 +123,9 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
metrics_proto.set_channel_mask(channel_mask); metrics_proto.set_channel_mask(channel_mask);
} }
// item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str()); // item->setCString(MM_PREFIX "encoding", toString(mFormat).c_str());
char *encoding = NULL; std::string encoding;
if (item->getCString(MM_PREFIX "encoding", &encoding)) { if (item->getString(MM_PREFIX "encoding", &encoding)) {
metrics_proto.set_encoding(encoding); metrics_proto.set_encoding(std::move(encoding));
} }
// item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount); // item->setInt32(MM_PREFIX "frameCount", (int32_t)mFrameCount);
int32_t frame_count = -1; int32_t frame_count = -1;
@ -133,14 +133,14 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
metrics_proto.set_frame_count(frame_count); metrics_proto.set_frame_count(frame_count);
} }
// item->setCString(MM_PREFIX "outDevice", toString(mOutDevice).c_str()); // item->setCString(MM_PREFIX "outDevice", toString(mOutDevice).c_str());
char *outDevice = NULL; std::string outDevice;
if (item->getCString(MM_PREFIX "outDevice", &outDevice)) { if (item->getString(MM_PREFIX "outDevice", &outDevice)) {
metrics_proto.set_output_device(outDevice); metrics_proto.set_output_device(std::move(outDevice));
} }
// item->setCString(MM_PREFIX "inDevice", toString(mInDevice).c_str()); // item->setCString(MM_PREFIX "inDevice", toString(mInDevice).c_str());
char *inDevice = NULL; std::string inDevice;
if (item->getCString(MM_PREFIX "inDevice", &inDevice)) { if (item->getString(MM_PREFIX "inDevice", &inDevice)) {
metrics_proto.set_input_device(inDevice); metrics_proto.set_input_device(std::move(inDevice));
} }
// item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean()); // item->setDouble(MM_PREFIX "ioJitterMs.mean", mIoJitterMs.getMean());
double iojitters_ms_mean = -1; double iojitters_ms_mean = -1;
@ -201,16 +201,6 @@ bool statsd_audiothread(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(mytype);
free(workhist);
free(latencyhist);
free(warmuphist);
free(type);
free(encoding);
free(inDevice);
free(outDevice);
return true; return true;
} }

37
services/mediaanalytics/statsd_audiotrack.cpp
Unescape View File

@ -57,23 +57,23 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
// static constexpr char kAudioTrackStreamType[] = "android.media.audiotrack.streamtype"; // static constexpr char kAudioTrackStreamType[] = "android.media.audiotrack.streamtype";
// optional string streamType; // optional string streamType;
char *streamtype = NULL; std::string streamtype;
if (item->getCString("android.media.audiotrack.streamtype", &streamtype)) { if (item->getString("android.media.audiotrack.streamtype", &streamtype)) {
metrics_proto.set_stream_type(streamtype); metrics_proto.set_stream_type(std::move(streamtype));
} }
// static constexpr char kAudioTrackContentType[] = "android.media.audiotrack.type"; // static constexpr char kAudioTrackContentType[] = "android.media.audiotrack.type";
// optional string contentType; // optional string contentType;
char *contenttype = NULL; std::string contenttype;
if (item->getCString("android.media.audiotrack.type", &contenttype)) { if (item->getString("android.media.audiotrack.type", &contenttype)) {
metrics_proto.set_content_type(contenttype); metrics_proto.set_content_type(std::move(contenttype));
} }
// static constexpr char kAudioTrackUsage[] = "android.media.audiotrack.usage"; // static constexpr char kAudioTrackUsage[] = "android.media.audiotrack.usage";
// optional string trackUsage; // optional string trackUsage;
char *trackusage = NULL; std::string trackusage;
if (item->getCString("android.media.audiotrack.usage", &trackusage)) { if (item->getString("android.media.audiotrack.usage", &trackusage)) {
metrics_proto.set_track_usage(trackusage); metrics_proto.set_track_usage(std::move(trackusage));
} }
// static constexpr char kAudioTrackSampleRate[] = "android.media.audiotrack.samplerate"; // static constexpr char kAudioTrackSampleRate[] = "android.media.audiotrack.samplerate";
@ -111,9 +111,9 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
metrics_proto.set_port_id(port_id); metrics_proto.set_port_id(port_id);
} }
// encoding (string) // encoding (string)
char *encoding = NULL; std::string encoding;
if (item->getCString("android.media.audiotrack.encoding", &encoding)) { if (item->getString("android.media.audiotrack.encoding", &encoding)) {
metrics_proto.set_encoding(encoding); metrics_proto.set_encoding(std::move(encoding));
} }
// frameCount (int32) // frameCount (int32)
int32_t frame_count = -1; int32_t frame_count = -1;
@ -121,9 +121,9 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
metrics_proto.set_frame_count(frame_count); metrics_proto.set_frame_count(frame_count);
} }
// attributes (string) // attributes (string)
char *attributes = NULL; std::string attributes;
if (item->getCString("android.media.audiotrack.attributes", &attributes)) { if (item->getString("android.media.audiotrack.attributes", &attributes)) {
metrics_proto.set_attributes(attributes); metrics_proto.set_attributes(std::move(attributes));
} }
std::string serialized; std::string serialized;
@ -143,13 +143,6 @@ bool statsd_audiotrack(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(streamtype);
free(contenttype);
free(trackusage);
free(encoding);
free(attributes);
return true; return true;
} }

30
services/mediaanalytics/statsd_codec.cpp
Unescape View File

@ -55,19 +55,19 @@ bool statsd_codec(MediaAnalyticsItem *item)
// flesh out the protobuf we'll hand off with our data // flesh out the protobuf we'll hand off with our data
// //
// android.media.mediacodec.codec string // android.media.mediacodec.codec string
char *codec = NULL; std::string codec;
if (item->getCString("android.media.mediacodec.codec", &codec)) { if (item->getString("android.media.mediacodec.codec", &codec)) {
metrics_proto.set_codec(codec); metrics_proto.set_codec(std::move(codec));
} }
// android.media.mediacodec.mime string // android.media.mediacodec.mime string
char *mime = NULL; std::string mime;
if (item->getCString("android.media.mediacodec.mime", &mime)) { if (item->getString("android.media.mediacodec.mime", &mime)) {
metrics_proto.set_mime(mime); metrics_proto.set_mime(std::move(mime));
} }
// android.media.mediacodec.mode string // android.media.mediacodec.mode string
char *mode = NULL; std::string mode;
if ( item->getCString("android.media.mediacodec.mode", &mode)) { if ( item->getString("android.media.mediacodec.mode", &mode)) {
metrics_proto.set_mode(mode); metrics_proto.set_mode(std::move(mode));
} }
// android.media.mediacodec.encoder int32 // android.media.mediacodec.encoder int32
int32_t encoder = -1; int32_t encoder = -1;
@ -125,9 +125,9 @@ bool statsd_codec(MediaAnalyticsItem *item)
metrics_proto.set_error_code(errcode); metrics_proto.set_error_code(errcode);
} }
// android.media.mediacodec.errstate string // android.media.mediacodec.errstate string
char *errstate = NULL; std::string errstate;
if ( item->getCString("android.media.mediacodec.errstate", &errstate)) { if ( item->getString("android.media.mediacodec.errstate", &errstate)) {
metrics_proto.set_error_state(errstate); metrics_proto.set_error_state(std::move(errstate));
} }
// android.media.mediacodec.latency.max int64 // android.media.mediacodec.latency.max int64
int64_t latency_max = -1; int64_t latency_max = -1;
@ -173,12 +173,6 @@ bool statsd_codec(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(codec);
free(mime);
free(mode);
free(errstate);
return true; return true;
} }

16
services/mediaanalytics/statsd_extractor.cpp
Unescape View File

@ -56,14 +56,14 @@ bool statsd_extractor(MediaAnalyticsItem *item)
// //
// android.media.mediaextractor.fmt string // android.media.mediaextractor.fmt string
char *fmt = NULL; std::string fmt;
if (item->getCString("android.media.mediaextractor.fmt", &fmt)) { if (item->getString("android.media.mediaextractor.fmt", &fmt)) {
metrics_proto.set_format(fmt); metrics_proto.set_format(std::move(fmt));
} }
// android.media.mediaextractor.mime string // android.media.mediaextractor.mime string
char *mime = NULL; std::string mime;
if (item->getCString("android.media.mediaextractor.mime", &mime)) { if (item->getString("android.media.mediaextractor.mime", &mime)) {
metrics_proto.set_mime(mime); metrics_proto.set_mime(std::move(mime));
} }
// android.media.mediaextractor.ntrk int32 // android.media.mediaextractor.ntrk int32
int32_t ntrk = -1; int32_t ntrk = -1;
@ -88,10 +88,6 @@ bool statsd_extractor(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(fmt);
free(mime);
return true; return true;
} }

44
services/mediaanalytics/statsd_nuplayer.cpp
Unescape View File

@ -62,13 +62,13 @@ bool statsd_nuplayer(MediaAnalyticsItem *item)
// differentiate between nuplayer and nuplayer2 // differentiate between nuplayer and nuplayer2
metrics_proto.set_whichplayer(item->getKey().c_str()); metrics_proto.set_whichplayer(item->getKey().c_str());
char *video_mime = NULL; std::string video_mime;
if (item->getCString("android.media.mediaplayer.video.mime", &video_mime)) { if (item->getString("android.media.mediaplayer.video.mime", &video_mime)) {
metrics_proto.set_video_mime(video_mime); metrics_proto.set_video_mime(std::move(video_mime));
} }
char *video_codec = NULL; std::string video_codec;
if (item->getCString("android.media.mediaplayer.video.codec", &video_codec)) { if (item->getString("android.media.mediaplayer.video.codec", &video_codec)) {
metrics_proto.set_video_codec(video_codec); metrics_proto.set_video_codec(std::move(video_codec));
} }
int32_t width = -1; int32_t width = -1;
@ -97,13 +97,13 @@ bool statsd_nuplayer(MediaAnalyticsItem *item)
metrics_proto.set_framerate(fps); metrics_proto.set_framerate(fps);
} }
char *audio_mime = NULL; std::string audio_mime;
if (item->getCString("android.media.mediaplayer.audio.mime", &audio_mime)) { if (item->getString("android.media.mediaplayer.audio.mime", &audio_mime)) {
metrics_proto.set_audio_mime(audio_mime); metrics_proto.set_audio_mime(std::move(audio_mime));
} }
char *audio_codec = NULL; std::string audio_codec;
if (item->getCString("android.media.mediaplayer.audio.codec", &audio_codec)) { if (item->getString("android.media.mediaplayer.audio.codec", &audio_codec)) {
metrics_proto.set_audio_codec(audio_codec); metrics_proto.set_audio_codec(std::move(audio_codec));
} }
int64_t duration_ms = -1; int64_t duration_ms = -1;
@ -123,14 +123,14 @@ bool statsd_nuplayer(MediaAnalyticsItem *item)
if (item->getInt32("android.media.mediaplayer.errcode", &error_code)) { if (item->getInt32("android.media.mediaplayer.errcode", &error_code)) {
metrics_proto.set_error_code(error_code); metrics_proto.set_error_code(error_code);
} }
char *error_state = NULL; std::string error_state;
if (item->getCString("android.media.mediaplayer.errstate", &error_state)) { if (item->getString("android.media.mediaplayer.errstate", &error_state)) {
metrics_proto.set_error_state(error_state); metrics_proto.set_error_state(std::move(error_state));
} }
char *data_source_type = NULL; std::string data_source_type;
if (item->getCString("android.media.mediaplayer.dataSource", &data_source_type)) { if (item->getString("android.media.mediaplayer.dataSource", &data_source_type)) {
metrics_proto.set_data_source_type(data_source_type); metrics_proto.set_data_source_type(std::move(data_source_type));
} }
int64_t rebufferingMs = -1; int64_t rebufferingMs = -1;
@ -164,14 +164,6 @@ bool statsd_nuplayer(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(video_mime);
free(video_codec);
free(audio_mime);
free(audio_codec);
free(error_state);
free(data_source_type);
return true; return true;
} }

16
services/mediaanalytics/statsd_recorder.cpp
Unescape View File

@ -56,14 +56,14 @@ bool statsd_recorder(MediaAnalyticsItem *item)
// //
// string kRecorderAudioMime = "android.media.mediarecorder.audio.mime"; // string kRecorderAudioMime = "android.media.mediarecorder.audio.mime";
char *audio_mime = NULL; std::string audio_mime;
if (item->getCString("android.media.mediarecorder.audio.mime", &audio_mime)) { if (item->getString("android.media.mediarecorder.audio.mime", &audio_mime)) {
metrics_proto.set_audio_mime(audio_mime); metrics_proto.set_audio_mime(std::move(audio_mime));
} }
// string kRecorderVideoMime = "android.media.mediarecorder.video.mime"; // string kRecorderVideoMime = "android.media.mediarecorder.video.mime";
char *video_mime = NULL; std::string video_mime;
if (item->getCString("android.media.mediarecorder.video.mime", &video_mime)) { if (item->getString("android.media.mediarecorder.video.mime", &video_mime)) {
metrics_proto.set_video_mime(video_mime); metrics_proto.set_video_mime(std::move(video_mime));
} }
// int32 kRecorderVideoProfile = "android.media.mediarecorder.video-encoder-profile"; // int32 kRecorderVideoProfile = "android.media.mediarecorder.video-encoder-profile";
int32_t videoProfile = -1; int32_t videoProfile = -1;
@ -183,10 +183,6 @@ bool statsd_recorder(MediaAnalyticsItem *item)
ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str())); ALOGV("NOT sending: private data (len=%zu)", strlen(serialized.c_str()));
} }
// must free the strings that we were given
free(audio_mime);
free(video_mime);
return true; return true;
} }

Write Preview
Loading…
Cancel
Save