Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Use uint64_t instead of long long as API type for consistent reason." into pi-dev

Browse Source 
am: 88840820d0

Change-Id: I87fe28665b2fa05d54bd2cd5a55728bcad0659c2
This commit is contained in:
Yi Jin
2018-03-06 21:03:49 +00:00
committed by android-build-merger
parent c6667aada1 88840820d0
commit db8bc9ba01
23 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmds/incident_helper/src/ih_util.cpp
View File

@@ -440,7 +440,7 @@ void
Message::startSession(ProtoOutputStream* proto, const string& name) Message::startSession(ProtoOutputStream* proto, const string& name)
{ {
uint64_t fieldId = mTable->mFields[name]; uint64_t fieldId = mTable->mFields[name];
long long token = proto->start(fieldId); uint64_t token = proto->start(fieldId);
mPreviousField = name; mPreviousField = name;
mTokens.push(token); mTokens.push(token);
} }

2
cmds/incident_helper/src/ih_util.h
View File

@@ -194,7 +194,7 @@ public:
private: private:
Table* mTable; Table* mTable;
std::string mPreviousField; std::string mPreviousField;
stack<long long> mTokens; stack<uint64_t> mTokens;
map<std::string, Message*> mSubMessages; map<std::string, Message*> mSubMessages;
}; };

4
cmds/incident_helper/src/parsers/CpuFreqParser.cpp
View File

@@ -65,10 +65,10 @@ CpuFreqParser::Parse(const int in, const int out) const
proto.write(CpuFreqProto::JIFFY_HZ, (int)jiffyHz); proto.write(CpuFreqProto::JIFFY_HZ, (int)jiffyHz);
for (int i=0; i<numCpus; i++) { for (int i=0; i<numCpus; i++) {
long long token = proto.start(CpuFreqProto::CPU_FREQS); uint64_t token = proto.start(CpuFreqProto::CPU_FREQS);
proto.write(CpuFreqProto::Stats::CPU_NAME, header[i+1]); proto.write(CpuFreqProto::Stats::CPU_NAME, header[i+1]);
for (vector<pair<int, long long>>::iterator it = cpucores[i].begin(); it != cpucores[i].end(); it++) { for (vector<pair<int, long long>>::iterator it = cpucores[i].begin(); it != cpucores[i].end(); it++) {
long long stateToken = proto.start(CpuFreqProto::Stats::TIMES); uint64_t stateToken = proto.start(CpuFreqProto::Stats::TIMES);
proto.write(CpuFreqProto::Stats::TimeInState::STATE_KHZ, it->first); proto.write(CpuFreqProto::Stats::TimeInState::STATE_KHZ, it->first);
proto.write(CpuFreqProto::Stats::TimeInState::TIME_JIFFY, it->second); proto.write(CpuFreqProto::Stats::TimeInState::TIME_JIFFY, it->second);
proto.end(stateToken); proto.end(stateToken);

4
cmds/incident_helper/src/parsers/CpuInfoParser.cpp
View File

@@ -28,7 +28,7 @@ static void writeSuffixLine(ProtoOutputStream* proto, uint64_t fieldId,
const int count, const char* names[], const uint64_t ids[]) const int count, const char* names[], const uint64_t ids[])
{ {
record_t record = parseRecord(line, delimiter); record_t record = parseRecord(line, delimiter);
long long token = proto->start(fieldId); uint64_t token = proto->start(fieldId);
for (int i=0; i<(int)record.size(); i++) { for (int i=0; i<(int)record.size(); i++) {
for (int j=0; j<count; j++) { for (int j=0; j<count; j++) {
if (stripSuffix(&record[i], names[j], true)) { if (stripSuffix(&record[i], names[j], true)) {
@@ -138,7 +138,7 @@ CpuInfoParser::Parse(const int in, const int out) const
continue; continue;
} }
long long token = proto.start(CpuInfoProto::TASKS); uint64_t token = proto.start(CpuInfoProto::TASKS);
for (int i=0; i<(int)record.size(); i++) { for (int i=0; i<(int)record.size(); i++) {
if (!table.insertField(&proto, header[i], record[i])) { if (!table.insertField(&proto, header[i], record[i])) {
fprintf(stderr, "[%s]Line %d fails to insert field %s with value %s\n", fprintf(stderr, "[%s]Line %d fails to insert field %s with value %s\n",

4
cmds/incident_helper/src/parsers/EventLogTagsParser.cpp
View File

@@ -41,7 +41,7 @@ EventLogTagsParser::Parse(const int in, const int out) const
continue; continue;
} }
long long token = proto.start(EventLogTagMapProto::EVENT_LOG_TAGS); uint64_t token = proto.start(EventLogTagMapProto::EVENT_LOG_TAGS);
proto.write(EventLogTag::TAG_NUMBER, toInt(tagNumber)); proto.write(EventLogTag::TAG_NUMBER, toInt(tagNumber));
proto.write(EventLogTag::TAG_NAME, tagName); proto.write(EventLogTag::TAG_NAME, tagName);
@@ -52,7 +52,7 @@ EventLogTagsParser::Parse(const int in, const int out) const
// If the parts doesn't contains pipe, then skips it. // If the parts doesn't contains pipe, then skips it.
continue; continue;
} }
long long descriptorToken = proto.start(EventLogTag::VALUE_DESCRIPTORS); uint64_t descriptorToken = proto.start(EventLogTag::VALUE_DESCRIPTORS);
proto.write(EventLogTag::ValueDescriptor::NAME, valueDescriptor[0]); proto.write(EventLogTag::ValueDescriptor::NAME, valueDescriptor[0]);
proto.write(EventLogTag::ValueDescriptor::TYPE, toInt(valueDescriptor[1])); proto.write(EventLogTag::ValueDescriptor::TYPE, toInt(valueDescriptor[1]));
if (valueDescriptor.size() == 3) { if (valueDescriptor.size() == 3) {

2
cmds/incident_helper/src/parsers/KernelWakesParser.cpp
View File

@@ -59,7 +59,7 @@ KernelWakesParser::Parse(const int in, const int out) const
continue; continue;
} }
long long token = proto.start(KernelWakeSourcesProto::WAKEUP_SOURCES); uint64_t token = proto.start(KernelWakeSourcesProto::WAKEUP_SOURCES);
for (int i=0; i<(int)record.size(); i++) { for (int i=0; i<(int)record.size(); i++) {
if (!table.insertField(&proto, header[i], record[i])) { if (!table.insertField(&proto, header[i], record[i])) {
fprintf(stderr, "[%s]Line %d has bad value %s of %s\n", fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",

4
cmds/incident_helper/src/parsers/PageTypeInfoParser.cpp
View File

@@ -64,7 +64,7 @@ PageTypeInfoParser::Parse(const int in, const int out) const
record_t record = parseRecord(line, COMMA_DELIMITER); record_t record = parseRecord(line, COMMA_DELIMITER);
if (migrateTypeSession && record.size() == 3) { if (migrateTypeSession && record.size() == 3) {
long long token = proto.start(PageTypeInfoProto::MIGRATE_TYPES); uint64_t token = proto.start(PageTypeInfoProto::MIGRATE_TYPES);
// expect part 0 starts with "Node" // expect part 0 starts with "Node"
if (stripPrefix(&record[0], "Node")) { if (stripPrefix(&record[0], "Node")) {
proto.write(PageTypeInfoProto::MigrateType::NODE, toInt(record[0])); proto.write(PageTypeInfoProto::MigrateType::NODE, toInt(record[0]));
@@ -93,7 +93,7 @@ PageTypeInfoParser::Parse(const int in, const int out) const
proto.end(token); proto.end(token);
} else if (!blockHeader.empty() && record.size() == 2) { } else if (!blockHeader.empty() && record.size() == 2) {
long long token = proto.start(PageTypeInfoProto::BLOCKS); uint64_t token = proto.start(PageTypeInfoProto::BLOCKS);
if (stripPrefix(&record[0], "Node")) { if (stripPrefix(&record[0], "Node")) {
proto.write(PageTypeInfoProto::Block::NODE, toInt(record[0])); proto.write(PageTypeInfoProto::Block::NODE, toInt(record[0]));
} else return BAD_VALUE; } else return BAD_VALUE;

10
cmds/incident_helper/src/parsers/ProcrankParser.cpp
View File

@@ -66,7 +66,7 @@ ProcrankParser::Parse(const int in, const int out) const
continue; continue;
} }
long long token = proto.start(ProcrankProto::PROCESSES); uint64_t token = proto.start(ProcrankProto::PROCESSES);
for (int i=0; i<(int)record.size(); i++) { for (int i=0; i<(int)record.size(); i++) {
if (!table.insertField(&proto, header[i], record[i])) { if (!table.insertField(&proto, header[i], record[i])) {
fprintf(stderr, "[%s]Line %d has bad value %s of %s\n", fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",
@@ -77,22 +77,22 @@ ProcrankParser::Parse(const int in, const int out) const
} }
// add summary // add summary
long long token = proto.start(ProcrankProto::SUMMARY); uint64_t token = proto.start(ProcrankProto::SUMMARY);
if (!total.empty()) { if (!total.empty()) {
record = parseRecord(total); record = parseRecord(total);
long long token = proto.start(ProcrankProto::Summary::TOTAL); uint64_t token = proto.start(ProcrankProto::Summary::TOTAL);
for (int i=(int)record.size(); i>0; i--) { for (int i=(int)record.size(); i>0; i--) {
table.insertField(&proto, header[header.size() - i].c_str(), record[record.size() - i].c_str()); table.insertField(&proto, header[header.size() - i].c_str(), record[record.size() - i].c_str());
} }
proto.end(token); proto.end(token);
} }
if (!zram.empty()) { if (!zram.empty()) {
long long token = proto.start(ProcrankProto::Summary::ZRAM); uint64_t token = proto.start(ProcrankProto::Summary::ZRAM);
proto.write(ProcrankProto::Summary::Zram::RAW_TEXT, zram); proto.write(ProcrankProto::Summary::Zram::RAW_TEXT, zram);
proto.end(token); proto.end(token);
} }
if (!ram.empty()) { if (!ram.empty()) {
long long token = proto.start(ProcrankProto::Summary::RAM); uint64_t token = proto.start(ProcrankProto::Summary::RAM);
proto.write(ProcrankProto::Summary::Ram::RAW_TEXT, ram); proto.write(ProcrankProto::Summary::Ram::RAW_TEXT, ram);
proto.end(token); proto.end(token);
} }

2
cmds/incident_helper/src/parsers/PsParser.cpp
View File

@@ -71,7 +71,7 @@ status_t PsParser::Parse(const int in, const int out) const {
continue; continue;
} }
long long token = proto.start(PsProto::PROCESSES); uint64_t token = proto.start(PsProto::PROCESSES);
for (int i=0; i<(int)record.size(); i++) { for (int i=0; i<(int)record.size(); i++) {
if (!table.insertField(&proto, header[i], record[i])) { if (!table.insertField(&proto, header[i], record[i])) {
fprintf(stderr, "[%s]Line %d has bad value %s of %s\n", fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",

2
cmds/incident_helper/src/parsers/SystemPropertiesParser.cpp
View File

@@ -207,7 +207,7 @@ SystemPropertiesParser::Parse(const int in, const int out) const
sysProp.endSession(&proto); sysProp.endSession(&proto);
for (auto it = extras.begin(); it != extras.end(); it++) { for (auto it = extras.begin(); it != extras.end(); it++) {
long long token = proto.start(SystemPropertiesProto::EXTRA_PROPERTIES); uint64_t token = proto.start(SystemPropertiesProto::EXTRA_PROPERTIES);
proto.write(SystemPropertiesProto::Property::NAME, it->first); proto.write(SystemPropertiesProto::Property::NAME, it->first);
proto.write(SystemPropertiesProto::Property::VALUE, it->second); proto.write(SystemPropertiesProto::Property::VALUE, it->second);
proto.end(token); proto.end(token);

2
cmds/incidentd/src/PrivacyBuffer.cpp
View File

@@ -91,7 +91,7 @@ status_t PrivacyBuffer::stripField(const Privacy* parentPolicy, const PrivacySpe
// current field is message type and its sub-fields have extra privacy policies // current field is message type and its sub-fields have extra privacy policies
uint32_t msgSize = mData.readRawVarint(); uint32_t msgSize = mData.readRawVarint();
size_t start = mData.rp()->pos(); size_t start = mData.rp()->pos();
long long token = mProto.start(encode_field_id(policy)); uint64_t token = mProto.start(encode_field_id(policy));
while (mData.rp()->pos() - start != msgSize) { while (mData.rp()->pos() - start != msgSize) {
status_t err = stripField(policy, spec, depth + 1); status_t err = stripField(policy, spec, depth + 1);
if (err != NO_ERROR) return err; if (err != NO_ERROR) return err;

6
cmds/incidentd/src/Section.cpp
View File

@@ -735,7 +735,7 @@ status_t LogSection::BlockingCall(int pipeWriteFd) const {
lastTimestamp.tv_nsec = msg.entry_v1.nsec; lastTimestamp.tv_nsec = msg.entry_v1.nsec;
// format a BinaryLogEntry // format a BinaryLogEntry
long long token = proto.start(LogProto::BINARY_LOGS); uint64_t token = proto.start(LogProto::BINARY_LOGS);
proto.write(BinaryLogEntry::SEC, msg.entry_v1.sec); proto.write(BinaryLogEntry::SEC, msg.entry_v1.sec);
proto.write(BinaryLogEntry::NANOSEC, msg.entry_v1.nsec); proto.write(BinaryLogEntry::NANOSEC, msg.entry_v1.nsec);
proto.write(BinaryLogEntry::UID, (int)msg.entry_v4.uid); proto.write(BinaryLogEntry::UID, (int)msg.entry_v4.uid);
@@ -745,7 +745,7 @@ status_t LogSection::BlockingCall(int pipeWriteFd) const {
get4LE(reinterpret_cast<uint8_t const*>(msg.msg()))); get4LE(reinterpret_cast<uint8_t const*>(msg.msg())));
do { do {
elem = android_log_read_next(context); elem = android_log_read_next(context);
long long elemToken = proto.start(BinaryLogEntry::ELEMS); uint64_t elemToken = proto.start(BinaryLogEntry::ELEMS);
switch (elem.type) { switch (elem.type) {
case EVENT_TYPE_INT: case EVENT_TYPE_INT:
proto.write(BinaryLogEntry::Elem::TYPE, proto.write(BinaryLogEntry::Elem::TYPE,
@@ -797,7 +797,7 @@ status_t LogSection::BlockingCall(int pipeWriteFd) const {
lastTimestamp.tv_nsec = entry.tv_nsec; lastTimestamp.tv_nsec = entry.tv_nsec;
// format a TextLogEntry // format a TextLogEntry
long long token = proto.start(LogProto::TEXT_LOGS); uint64_t token = proto.start(LogProto::TEXT_LOGS);
proto.write(TextLogEntry::SEC, (long long)entry.tv_sec); proto.write(TextLogEntry::SEC, (long long)entry.tv_sec);
proto.write(TextLogEntry::NANOSEC, (long long)entry.tv_nsec); proto.write(TextLogEntry::NANOSEC, (long long)entry.tv_nsec);
proto.write(TextLogEntry::PRIORITY, (int)entry.priority); proto.write(TextLogEntry::PRIORITY, (int)entry.priority);

4
cmds/statsd/src/StatsLogProcessor.cpp
View File

@@ -249,14 +249,14 @@ void StatsLogProcessor::onDumpReportLocked(const ConfigKey& key, const uint64_t
ProtoOutputStream proto; ProtoOutputStream proto;
// Start of ConfigKey. // Start of ConfigKey.
long long configKeyToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_CONFIG_KEY); uint64_t configKeyToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_CONFIG_KEY);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID, key.GetUid()); proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID, key.GetUid());
proto.write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)key.GetId()); proto.write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)key.GetId());
proto.end(configKeyToken); proto.end(configKeyToken);
// End of ConfigKey. // End of ConfigKey.
// Start of ConfigMetricsReport (reports). // Start of ConfigMetricsReport (reports).
long long reportsToken = uint64_t reportsToken =
proto.start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS); proto.start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS);
int64_t lastReportTimeNs = it->second->getLastReportTimeNs(); int64_t lastReportTimeNs = it->second->getLastReportTimeNs();

20
cmds/statsd/src/guardrail/StatsdStats.cpp
View File

@@ -455,7 +455,7 @@ void StatsdStats::dumpStats(FILE* out) const {
} }
void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* proto) { void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* proto) {
long long token = uint64_t token =
proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS); proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS);
proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_UID, configStats.uid); proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_UID, configStats.uid);
proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ID, (long long)configStats.id); proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ID, (long long)configStats.id);
@@ -487,7 +487,7 @@ void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* pr
} }
for (const auto& pair : configStats.matcher_stats) { for (const auto& pair : configStats.matcher_stats) {
long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
FIELD_ID_CONFIG_STATS_MATCHER_STATS); FIELD_ID_CONFIG_STATS_MATCHER_STATS);
proto->write(FIELD_TYPE_INT64 | FIELD_ID_MATCHER_STATS_ID, (long long)pair.first); proto->write(FIELD_TYPE_INT64 | FIELD_ID_MATCHER_STATS_ID, (long long)pair.first);
proto->write(FIELD_TYPE_INT32 | FIELD_ID_MATCHER_STATS_COUNT, pair.second); proto->write(FIELD_TYPE_INT32 | FIELD_ID_MATCHER_STATS_COUNT, pair.second);
@@ -495,7 +495,7 @@ void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* pr
} }
for (const auto& pair : configStats.condition_stats) { for (const auto& pair : configStats.condition_stats) {
long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
FIELD_ID_CONFIG_STATS_CONDITION_STATS); FIELD_ID_CONFIG_STATS_CONDITION_STATS);
proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONDITION_STATS_ID, (long long)pair.first); proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONDITION_STATS_ID, (long long)pair.first);
proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONDITION_STATS_COUNT, pair.second); proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONDITION_STATS_COUNT, pair.second);
@@ -503,7 +503,7 @@ void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* pr
} }
for (const auto& pair : configStats.metric_stats) { for (const auto& pair : configStats.metric_stats) {
long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
FIELD_ID_CONFIG_STATS_METRIC_STATS); FIELD_ID_CONFIG_STATS_METRIC_STATS);
proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first); proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first);
proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second); proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second);
@@ -511,7 +511,7 @@ void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* pr
} }
for (const auto& pair : configStats.alert_stats) { for (const auto& pair : configStats.alert_stats) {
long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
FIELD_ID_CONFIG_STATS_ALERT_STATS); FIELD_ID_CONFIG_STATS_ALERT_STATS);
proto->write(FIELD_TYPE_INT64 | FIELD_ID_ALERT_STATS_ID, (long long)pair.first); proto->write(FIELD_TYPE_INT64 | FIELD_ID_ALERT_STATS_ID, (long long)pair.first);
proto->write(FIELD_TYPE_INT32 | FIELD_ID_ALERT_STATS_COUNT, pair.second); proto->write(FIELD_TYPE_INT32 | FIELD_ID_ALERT_STATS_COUNT, pair.second);
@@ -539,7 +539,7 @@ void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) {
const size_t atomCounts = mPushedAtomStats.size(); const size_t atomCounts = mPushedAtomStats.size();
for (size_t i = 2; i < atomCounts; i++) { for (size_t i = 2; i < atomCounts; i++) {
if (mPushedAtomStats[i] > 0) { if (mPushedAtomStats[i] > 0) {
long long token = uint64_t token =
proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOM_STATS | FIELD_COUNT_REPEATED); proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOM_STATS | FIELD_COUNT_REPEATED);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_TAG, (int32_t)i); proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_TAG, (int32_t)i);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_COUNT, mPushedAtomStats[i]); proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_COUNT, mPushedAtomStats[i]);
@@ -552,20 +552,20 @@ void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) {
} }
if (mAnomalyAlarmRegisteredStats > 0) { if (mAnomalyAlarmRegisteredStats > 0) {
long long token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ANOMALY_ALARM_STATS); uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ANOMALY_ALARM_STATS);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_ANOMALY_ALARMS_REGISTERED, proto.write(FIELD_TYPE_INT32 | FIELD_ID_ANOMALY_ALARMS_REGISTERED,
mAnomalyAlarmRegisteredStats); mAnomalyAlarmRegisteredStats);
proto.end(token); proto.end(token);
} }
if (mPeriodicAlarmRegisteredStats > 0) { if (mPeriodicAlarmRegisteredStats > 0) {
long long token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_SUBSCRIBER_ALARM_STATS); uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_SUBSCRIBER_ALARM_STATS);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_SUBSCRIBER_ALARMS_REGISTERED, proto.write(FIELD_TYPE_INT32 | FIELD_ID_SUBSCRIBER_ALARMS_REGISTERED,
mPeriodicAlarmRegisteredStats); mPeriodicAlarmRegisteredStats);
proto.end(token); proto.end(token);
} }
long long uidMapToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS); uint64_t uidMapToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_SNAPSHOTS, mUidMapStats.snapshots); proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_SNAPSHOTS, mUidMapStats.snapshots);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_CHANGES, mUidMapStats.changes); proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_CHANGES, mUidMapStats.changes);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_BYTES_USED, mUidMapStats.bytes_used); proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_BYTES_USED, mUidMapStats.bytes_used);
@@ -575,7 +575,7 @@ void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) {
proto.end(uidMapToken); proto.end(uidMapToken);
for (const auto& error : mLoggerErrors) { for (const auto& error : mLoggerErrors) {
long long token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_LOGGER_ERROR_STATS | uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_LOGGER_ERROR_STATS |
FIELD_COUNT_REPEATED); FIELD_COUNT_REPEATED);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_TIME, error.first); proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_TIME, error.first);
proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_ERROR_CODE, error.second); proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_ERROR_CODE, error.second);

10
cmds/statsd/src/metrics/CountMetricProducer.cpp
View File

@@ -109,23 +109,23 @@ void CountMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
return; return;
} }
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId); protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId);
long long protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_COUNT_METRICS); uint64_t protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_COUNT_METRICS);
for (const auto& counter : mPastBuckets) { for (const auto& counter : mPastBuckets) {
const MetricDimensionKey& dimensionKey = counter.first; const MetricDimensionKey& dimensionKey = counter.first;
VLOG(" dimension key %s", dimensionKey.c_str()); VLOG(" dimension key %s", dimensionKey.c_str());
long long wrapperToken = uint64_t wrapperToken =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA);
// First fill dimension. // First fill dimension.
long long dimensionInWhatToken = protoOutput->start( uint64_t dimensionInWhatToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT);
writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput);
protoOutput->end(dimensionInWhatToken); protoOutput->end(dimensionInWhatToken);
if (dimensionKey.hasDimensionKeyInCondition()) { if (dimensionKey.hasDimensionKeyInCondition()) {
long long dimensionInConditionToken = protoOutput->start( uint64_t dimensionInConditionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION);
writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput);
protoOutput->end(dimensionInConditionToken); protoOutput->end(dimensionInConditionToken);
@@ -134,7 +134,7 @@ void CountMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
// Then fill bucket_info (CountBucketInfo). // Then fill bucket_info (CountBucketInfo).
for (const auto& bucket : counter.second) { for (const auto& bucket : counter.second) {
long long bucketInfoToken = protoOutput->start( uint64_t bucketInfoToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO); FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO);
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS, protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS,
(long long)bucket.mBucketStartNs); (long long)bucket.mBucketStartNs);

10
cmds/statsd/src/metrics/DurationMetricProducer.cpp
View File

@@ -235,7 +235,7 @@ void DurationMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
} }
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId); protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId);
long long protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_DURATION_METRICS); uint64_t protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_DURATION_METRICS);
VLOG("Duration metric %lld dump report now...", (long long)mMetricId); VLOG("Duration metric %lld dump report now...", (long long)mMetricId);
@@ -243,17 +243,17 @@ void DurationMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
const MetricDimensionKey& dimensionKey = pair.first; const MetricDimensionKey& dimensionKey = pair.first;
VLOG(" dimension key %s", dimensionKey.c_str()); VLOG(" dimension key %s", dimensionKey.c_str());
long long wrapperToken = uint64_t wrapperToken =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA);
// First fill dimension. // First fill dimension.
long long dimensionToken = protoOutput->start( uint64_t dimensionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT);
writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput);
protoOutput->end(dimensionToken); protoOutput->end(dimensionToken);
if (dimensionKey.hasDimensionKeyInCondition()) { if (dimensionKey.hasDimensionKeyInCondition()) {
long long dimensionInConditionToken = protoOutput->start( uint64_t dimensionInConditionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION);
writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput);
protoOutput->end(dimensionInConditionToken); protoOutput->end(dimensionInConditionToken);
@@ -261,7 +261,7 @@ void DurationMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
// Then fill bucket_info (DurationBucketInfo). // Then fill bucket_info (DurationBucketInfo).
for (const auto& bucket : pair.second) { for (const auto& bucket : pair.second) {
long long bucketInfoToken = protoOutput->start( uint64_t bucketInfoToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO); FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO);
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS, protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS,
(long long)bucket.mBucketStartNs); (long long)bucket.mBucketStartNs);

4
cmds/statsd/src/metrics/EventMetricProducer.cpp
View File

@@ -131,7 +131,7 @@ void EventMetricProducer::onMatchedLogEventInternalLocked(
return; return;
} }
long long wrapperToken = uint64_t wrapperToken =
mProto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA); mProto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA);
const bool truncateTimestamp = const bool truncateTimestamp =
android::util::kNotTruncatingTimestampAtomWhiteList.find(event.GetTagId()) == android::util::kNotTruncatingTimestampAtomWhiteList.find(event.GetTagId()) ==
@@ -148,7 +148,7 @@ void EventMetricProducer::onMatchedLogEventInternalLocked(
(long long)getWallClockNs()); (long long)getWallClockNs());
} }
long long eventToken = mProto->start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOMS); uint64_t eventToken = mProto->start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOMS);
event.ToProto(*mProto); event.ToProto(*mProto);
mProto->end(eventToken); mProto->end(eventToken);
mProto->end(wrapperToken); mProto->end(wrapperToken);

12
cmds/statsd/src/metrics/GaugeMetricProducer.cpp
View File

@@ -135,23 +135,23 @@ void GaugeMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
} }
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId); protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId);
long long protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_GAUGE_METRICS); uint64_t protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_GAUGE_METRICS);
for (const auto& pair : mPastBuckets) { for (const auto& pair : mPastBuckets) {
const MetricDimensionKey& dimensionKey = pair.first; const MetricDimensionKey& dimensionKey = pair.first;
VLOG(" dimension key %s", dimensionKey.c_str()); VLOG(" dimension key %s", dimensionKey.c_str());
long long wrapperToken = uint64_t wrapperToken =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA);
// First fill dimension. // First fill dimension.
long long dimensionToken = protoOutput->start( uint64_t dimensionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT);
writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput);
protoOutput->end(dimensionToken); protoOutput->end(dimensionToken);
if (dimensionKey.hasDimensionKeyInCondition()) { if (dimensionKey.hasDimensionKeyInCondition()) {
long long dimensionInConditionToken = protoOutput->start( uint64_t dimensionInConditionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION);
writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput);
protoOutput->end(dimensionInConditionToken); protoOutput->end(dimensionInConditionToken);
@@ -159,7 +159,7 @@ void GaugeMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
// Then fill bucket_info (GaugeBucketInfo). // Then fill bucket_info (GaugeBucketInfo).
for (const auto& bucket : pair.second) { for (const auto& bucket : pair.second) {
long long bucketInfoToken = protoOutput->start( uint64_t bucketInfoToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO); FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO);
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS, protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_ELAPSED_NANOS,
(long long)bucket.mBucketStartNs); (long long)bucket.mBucketStartNs);
@@ -167,7 +167,7 @@ void GaugeMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
(long long)bucket.mBucketEndNs); (long long)bucket.mBucketEndNs);
if (!bucket.mGaugeAtoms.empty()) { if (!bucket.mGaugeAtoms.empty()) {
long long atomsToken = uint64_t atomsToken =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_ATOM); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_ATOM);
for (const auto& atom : bucket.mGaugeAtoms) { for (const auto& atom : bucket.mGaugeAtoms) {
writeFieldValueTreeToStream(mTagId, *(atom.mFields), protoOutput); writeFieldValueTreeToStream(mTagId, *(atom.mFields), protoOutput);

2
cmds/statsd/src/metrics/MetricsManager.cpp
View File

@@ -186,7 +186,7 @@ void MetricsManager::onDumpReport(const uint64_t dumpTimeStampNs, ProtoOutputStr
// one StatsLogReport per MetricProduer // one StatsLogReport per MetricProduer
for (const auto& producer : mAllMetricProducers) { for (const auto& producer : mAllMetricProducers) {
if (mNoReportMetricIds.find(producer->getMetricId()) == mNoReportMetricIds.end()) { if (mNoReportMetricIds.find(producer->getMetricId()) == mNoReportMetricIds.end()) {
long long token = uint64_t token =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_METRICS); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_METRICS);
producer->onDumpReport(dumpTimeStampNs, protoOutput); producer->onDumpReport(dumpTimeStampNs, protoOutput);
protoOutput->end(token); protoOutput->end(token);

10
cmds/statsd/src/metrics/ValueMetricProducer.cpp
View File

@@ -142,21 +142,21 @@ void ValueMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
return; return;
} }
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId); protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)mMetricId);
long long protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_VALUE_METRICS); uint64_t protoToken = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_VALUE_METRICS);
for (const auto& pair : mPastBuckets) { for (const auto& pair : mPastBuckets) {
const MetricDimensionKey& dimensionKey = pair.first; const MetricDimensionKey& dimensionKey = pair.first;
VLOG(" dimension key %s", dimensionKey.c_str()); VLOG(" dimension key %s", dimensionKey.c_str());
long long wrapperToken = uint64_t wrapperToken =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_DATA);
// First fill dimension. // First fill dimension.
long long dimensionToken = protoOutput->start( uint64_t dimensionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_WHAT);
writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInWhat(), protoOutput);
protoOutput->end(dimensionToken); protoOutput->end(dimensionToken);
if (dimensionKey.hasDimensionKeyInCondition()) { if (dimensionKey.hasDimensionKeyInCondition()) {
long long dimensionInConditionToken = protoOutput->start( uint64_t dimensionInConditionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION); FIELD_TYPE_MESSAGE | FIELD_ID_DIMENSION_IN_CONDITION);
writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput); writeDimensionToProto(dimensionKey.getDimensionKeyInCondition(), protoOutput);
protoOutput->end(dimensionInConditionToken); protoOutput->end(dimensionInConditionToken);
@@ -164,7 +164,7 @@ void ValueMetricProducer::onDumpReportLocked(const uint64_t dumpTimeNs,
// Then fill bucket_info (ValueBucketInfo). // Then fill bucket_info (ValueBucketInfo).
for (const auto& bucket : pair.second) { for (const auto& bucket : pair.second) {
long long bucketInfoToken = protoOutput->start( uint64_t bucketInfoToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO); FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_BUCKET_INFO);
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_NANOS, protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_START_BUCKET_NANOS,
(long long)bucket.mBucketStartNs); (long long)bucket.mBucketStartNs);

14
cmds/statsd/src/stats_log_util.cpp
View File

@@ -70,7 +70,7 @@ void writeDimensionToProtoHelper(const std::vector<FieldValue>& dims, size_t* in
} }
if (depth == valueDepth && valuePrefix == prefix) { if (depth == valueDepth && valuePrefix == prefix) {
long long token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | uint64_t token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
DIMENSIONS_VALUE_TUPLE_VALUE); DIMENSIONS_VALUE_TUPLE_VALUE);
protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, fieldNum); protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, fieldNum);
switch (dim.mValue.getType()) { switch (dim.mValue.getType()) {
@@ -99,10 +99,10 @@ void writeDimensionToProtoHelper(const std::vector<FieldValue>& dims, size_t* in
(*index)++; (*index)++;
} else if (valueDepth > depth && valuePrefix == prefix) { } else if (valueDepth > depth && valuePrefix == prefix) {
// Writing the sub tree // Writing the sub tree
long long dimensionToken = protoOutput->start( uint64_t dimensionToken = protoOutput->start(
FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | DIMENSIONS_VALUE_TUPLE_VALUE); FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | DIMENSIONS_VALUE_TUPLE_VALUE);
protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, fieldNum); protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, fieldNum);
long long tupleToken = uint64_t tupleToken =
protoOutput->start(FIELD_TYPE_MESSAGE | DIMENSIONS_VALUE_VALUE_TUPLE); protoOutput->start(FIELD_TYPE_MESSAGE | DIMENSIONS_VALUE_VALUE_TUPLE);
writeDimensionToProtoHelper(dims, index, valueDepth, dim.mField.getPrefix(valueDepth), writeDimensionToProtoHelper(dims, index, valueDepth, dim.mField.getPrefix(valueDepth),
protoOutput); protoOutput);
@@ -123,7 +123,7 @@ void writeDimensionToProto(const HashableDimensionKey& dimension, ProtoOutputStr
} }
protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD,
dimension.getValues()[0].mField.getTag()); dimension.getValues()[0].mField.getTag());
long long topToken = protoOutput->start(FIELD_TYPE_MESSAGE | DIMENSIONS_VALUE_VALUE_TUPLE); uint64_t topToken = protoOutput->start(FIELD_TYPE_MESSAGE | DIMENSIONS_VALUE_VALUE_TUPLE);
size_t index = 0; size_t index = 0;
writeDimensionToProtoHelper(dimension.getValues(), &index, 0, 0, protoOutput); writeDimensionToProtoHelper(dimension.getValues(), &index, 0, 0, protoOutput);
protoOutput->end(topToken); protoOutput->end(topToken);
@@ -189,7 +189,7 @@ void writeFieldValueTreeToStreamHelper(const std::vector<FieldValue>& dims, size
(*index)++; (*index)++;
} else if (valueDepth > depth && valuePrefix == prefix) { } else if (valueDepth > depth && valuePrefix == prefix) {
// Writing the sub tree // Writing the sub tree
long long msg_token = 0; uint64_t msg_token = 0ULL;
if (valueDepth == depth + 2) { if (valueDepth == depth + 2) {
msg_token = msg_token =
protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | fieldNum); protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | fieldNum);
@@ -212,7 +212,7 @@ void writeFieldValueTreeToStreamHelper(const std::vector<FieldValue>& dims, size
void writeFieldValueTreeToStream(int tagId, const std::vector<FieldValue>& values, void writeFieldValueTreeToStream(int tagId, const std::vector<FieldValue>& values,
util::ProtoOutputStream* protoOutput) { util::ProtoOutputStream* protoOutput) {
long long atomToken = protoOutput->start(FIELD_TYPE_MESSAGE | tagId); uint64_t atomToken = protoOutput->start(FIELD_TYPE_MESSAGE | tagId);
size_t index = 0; size_t index = 0;
writeFieldValueTreeToStreamHelper(values, &index, 0, 0, protoOutput); writeFieldValueTreeToStreamHelper(values, &index, 0, 0, protoOutput);
@@ -257,7 +257,7 @@ int64_t TimeUnitToBucketSizeInMillis(TimeUnit unit) {
void writePullerStatsToStream(const std::pair<int, StatsdStats::PulledAtomStats>& pair, void writePullerStatsToStream(const std::pair<int, StatsdStats::PulledAtomStats>& pair,
util::ProtoOutputStream* protoOutput) { util::ProtoOutputStream* protoOutput) {
long long token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_PULLED_ATOM_STATS | uint64_t token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_PULLED_ATOM_STATS |
FIELD_COUNT_REPEATED); FIELD_COUNT_REPEATED);
protoOutput->write(FIELD_TYPE_INT32 | FIELD_ID_PULL_ATOM_ID, (int32_t)pair.first); protoOutput->write(FIELD_TYPE_INT32 | FIELD_ID_PULL_ATOM_ID, (int32_t)pair.first);
protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_TOTAL_PULL, (long long)pair.second.totalPull); protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_TOTAL_PULL, (long long)pair.second.totalPull);

8
libs/protoutil/include/android/util/ProtoOutputStream.h
View File

@@ -25,7 +25,7 @@ namespace android {
namespace util { namespace util {
/** /**
* Position of the field type in a (long long) fieldId. * Position of the field type in a 64-bits fieldId.
*/ */
const uint64_t FIELD_TYPE_SHIFT = 32; const uint64_t FIELD_TYPE_SHIFT = 32;
@@ -106,8 +106,8 @@ public:
* Returns a token of this write session. * Returns a token of this write session.
* Must call end(token) when finish write this sub-message. * Must call end(token) when finish write this sub-message.
*/ */
long long start(uint64_t fieldId); uint64_t start(uint64_t fieldId);
void end(long long token); void end(uint64_t token);
/** /**
* Returns how many bytes are buffered in ProtoOutputStream. * Returns how many bytes are buffered in ProtoOutputStream.
@@ -139,7 +139,7 @@ private:
bool mCompact; bool mCompact;
int mDepth; int mDepth;
int mObjectId; int mObjectId;
long long mExpectedObjectToken; uint64_t mExpectedObjectToken;
inline void writeDoubleImpl(uint32_t id, double val); inline void writeDoubleImpl(uint32_t id, double val);
inline void writeFloatImpl(uint32_t id, float val); inline void writeFloatImpl(uint32_t id, float val);

26
libs/protoutil/src/ProtoOutputStream.cpp
View File

@@ -28,7 +28,7 @@ ProtoOutputStream::ProtoOutputStream()
mCompact(false), mCompact(false),
mDepth(0), mDepth(0),
mObjectId(0), mObjectId(0),
mExpectedObjectToken(0LL) mExpectedObjectToken(0ULL)
{ {
} }
@@ -45,7 +45,7 @@ ProtoOutputStream::clear()
mCompact = false; mCompact = false;
mDepth = 0; mDepth = 0;
mObjectId = 0; mObjectId = 0;
mExpectedObjectToken = 0LL; mExpectedObjectToken = 0ULL;
} }
bool bool
@@ -222,37 +222,37 @@ ProtoOutputStream::write(uint64_t fieldId, const char* val, size_t size)
* because of the overflow, and only the tokens are compared. * because of the overflow, and only the tokens are compared.
* Bits 0-31 - offset of the first size field in the buffer. * Bits 0-31 - offset of the first size field in the buffer.
*/ */
long long uint64_t
makeToken(int tagSize, bool repeated, int depth, int objectId, int sizePos) { makeToken(int tagSize, bool repeated, int depth, int objectId, int sizePos) {
return ((0x07L & (long long)tagSize) << 61) return ((0x07L & (uint64_t)tagSize) << 61)
| (repeated ? (1LL << 60) : 0) | (repeated ? (1LL << 60) : 0)
| (0x01ffL & (long long)depth) << 51 | (0x01ffL & (uint64_t)depth) << 51
| (0x07ffffL & (long long)objectId) << 32 | (0x07ffffL & (uint64_t)objectId) << 32
| (0x0ffffffffL & (long long)sizePos); | (0x0ffffffffL & (uint64_t)sizePos);
} }
/** /**
* Get the encoded tag size from the token. * Get the encoded tag size from the token.
*/ */
static int getTagSizeFromToken(long long token) { static int getTagSizeFromToken(uint64_t token) {
return (int)(0x7 & (token >> 61)); return (int)(0x7 & (token >> 61));
} }
/** /**
* Get the nesting depth of startObject calls from the token. * Get the nesting depth of startObject calls from the token.
*/ */
static int getDepthFromToken(long long token) { static int getDepthFromToken(uint64_t token) {
return (int)(0x01ff & (token >> 51)); return (int)(0x01ff & (token >> 51));
} }
/** /**
* Get the location of the childRawSize (the first 32 bit size field) in this object. * Get the location of the childRawSize (the first 32 bit size field) in this object.
*/ */
static int getSizePosFromToken(long long token) { static int getSizePosFromToken(uint64_t token) {
return (int)token; return (int)token;
} }
long long uint64_t
ProtoOutputStream::start(uint64_t fieldId) ProtoOutputStream::start(uint64_t fieldId)
{ {
if ((fieldId & FIELD_TYPE_MASK) != FIELD_TYPE_MESSAGE) { if ((fieldId & FIELD_TYPE_MASK) != FIELD_TYPE_MESSAGE) {
@@ -275,10 +275,10 @@ ProtoOutputStream::start(uint64_t fieldId)
} }
void void
ProtoOutputStream::end(long long token) ProtoOutputStream::end(uint64_t token)
{ {
if (token != mExpectedObjectToken) { if (token != mExpectedObjectToken) {
ALOGE("Unexpected token: 0x%llx, should be 0x%llx", token, mExpectedObjectToken); ALOGE("Unexpected token: 0x%llx, should be 0x%llx", (long long)token, (long long)mExpectedObjectToken);
return; return;
} }