| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/metrics/persisted_logs.h" |
| |
| #include <string> |
| |
| #include "base/base64.h" |
| #include "base/md5.h" |
| #include "base/metrics/histogram.h" |
| #include "base/prefs/pref_service.h" |
| #include "base/prefs/scoped_user_pref_update.h" |
| #include "base/sha1.h" |
| #include "base/timer/elapsed_timer.h" |
| |
| namespace metrics { |
| |
| namespace { |
| |
| // We append (2) more elements to persisted lists: the size of the list and a |
| // checksum of the elements. |
| const size_t kChecksumEntryCount = 2; |
| |
| PersistedLogs::LogReadStatus MakeRecallStatusHistogram( |
| PersistedLogs::LogReadStatus status) { |
| UMA_HISTOGRAM_ENUMERATION("PrefService.PersistentLogRecallProtobufs", |
| status, PersistedLogs::END_RECALL_STATUS); |
| return status; |
| } |
| |
| } // namespace |
| |
| void PersistedLogs::LogHashPair::SwapLog(std::string* input) { |
| log.swap(*input); |
| if (!log.empty()) |
| hash = base::SHA1HashString(log); |
| else |
| hash.clear(); |
| } |
| |
| void PersistedLogs::LogHashPair::Swap(PersistedLogs::LogHashPair* input) { |
| log.swap(input->log); |
| hash.swap(input->hash); |
| } |
| |
| PersistedLogs::PersistedLogs(PrefService* local_state, |
| const char* pref_name, |
| size_t min_log_count, |
| size_t min_log_bytes, |
| size_t max_log_size) |
| : local_state_(local_state), |
| pref_name_(pref_name), |
| min_log_count_(min_log_count), |
| min_log_bytes_(min_log_bytes), |
| max_log_size_(max_log_size), |
| last_provisional_store_index_(-1) { |
| DCHECK(local_state_); |
| // One of the limit arguments must be non-zero. |
| DCHECK(min_log_count_ > 0 || min_log_bytes_ > 0); |
| } |
| |
| PersistedLogs::~PersistedLogs() {} |
| |
| void PersistedLogs::SerializeLogs() { |
| // Remove any logs that are over the serialization size limit. |
| if (max_log_size_) { |
| for (std::vector<LogHashPair>::iterator it = list_.begin(); |
| it != list_.end();) { |
| size_t log_size = it->log.length(); |
| if (log_size > max_log_size_) { |
| UMA_HISTOGRAM_COUNTS("UMA.Large Accumulated Log Not Persisted", |
| static_cast<int>(log_size)); |
| it = list_.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| } |
| ListPrefUpdate update(local_state_, pref_name_); |
| WriteLogsToPrefList(update.Get()); |
| } |
| |
| PersistedLogs::LogReadStatus PersistedLogs::DeserializeLogs() { |
| const base::ListValue* unsent_logs = local_state_->GetList(pref_name_); |
| return ReadLogsFromPrefList(*unsent_logs); |
| } |
| |
| void PersistedLogs::StoreLog(std::string* input) { |
| list_.push_back(LogHashPair()); |
| list_.back().SwapLog(input); |
| } |
| |
| void PersistedLogs::StageLog() { |
| // CHECK, rather than DCHECK, because swap()ing with an empty list causes |
| // hard-to-identify crashes much later. |
| CHECK(!list_.empty()); |
| DCHECK(!has_staged_log()); |
| staged_log_.Swap(&list_.back()); |
| list_.pop_back(); |
| |
| // If the staged log was the last provisional store, clear that. |
| if (static_cast<size_t>(last_provisional_store_index_) == list_.size()) |
| last_provisional_store_index_ = -1; |
| DCHECK(has_staged_log()); |
| } |
| |
| void PersistedLogs::DiscardStagedLog() { |
| DCHECK(has_staged_log()); |
| staged_log_.log.clear(); |
| } |
| |
| void PersistedLogs::StoreStagedLogAsUnsent(StoreType store_type) { |
| list_.push_back(LogHashPair()); |
| list_.back().Swap(&staged_log_); |
| if (store_type == PROVISIONAL_STORE) |
| last_provisional_store_index_ = list_.size() - 1; |
| } |
| |
| void PersistedLogs::DiscardLastProvisionalStore() { |
| if (last_provisional_store_index_ == -1) |
| return; |
| DCHECK_LT(static_cast<size_t>(last_provisional_store_index_), list_.size()); |
| list_.erase(list_.begin() + last_provisional_store_index_); |
| last_provisional_store_index_ = -1; |
| } |
| |
| void PersistedLogs::WriteLogsToPrefList(base::ListValue* list_value) { |
| list_value->Clear(); |
| |
| // Leave the list completely empty if there are no storable values. |
| if (list_.empty()) |
| return; |
| |
| size_t start = 0; |
| // If there are too many logs, keep the most recent logs up to the length |
| // limit, and at least to the minimum number of bytes. |
| if (list_.size() > min_log_count_) { |
| start = list_.size(); |
| size_t bytes_used = 0; |
| std::vector<LogHashPair>::const_reverse_iterator end = list_.rend(); |
| for (std::vector<LogHashPair>::const_reverse_iterator it = list_.rbegin(); |
| it != end; ++it) { |
| size_t log_size = it->log.length(); |
| if (bytes_used >= min_log_bytes_ && |
| (list_.size() - start) >= min_log_count_) { |
| break; |
| } |
| bytes_used += log_size; |
| --start; |
| } |
| } |
| DCHECK_LT(start, list_.size()); |
| if (start >= list_.size()) |
| return; |
| |
| // Store size at the beginning of the list_value. |
| list_value->Append(base::Value::CreateIntegerValue(list_.size() - start)); |
| |
| base::MD5Context ctx; |
| base::MD5Init(&ctx); |
| std::string encoded_log; |
| for (std::vector<LogHashPair>::const_iterator it = list_.begin() + start; |
| it != list_.end(); ++it) { |
| // We encode the compressed log as Value::CreateStringValue() expects to |
| // take a valid UTF8 string. |
| base::Base64Encode(it->log, &encoded_log); |
| base::MD5Update(&ctx, encoded_log); |
| list_value->Append(base::Value::CreateStringValue(encoded_log)); |
| } |
| |
| // Append hash to the end of the list_value. |
| base::MD5Digest digest; |
| base::MD5Final(&digest, &ctx); |
| list_value->Append(base::Value::CreateStringValue( |
| base::MD5DigestToBase16(digest))); |
| // Minimum of 3 elements (size, data, hash). |
| DCHECK_GE(list_value->GetSize(), 3U); |
| } |
| |
| PersistedLogs::LogReadStatus PersistedLogs::ReadLogsFromPrefList( |
| const base::ListValue& list_value) { |
| if (list_value.GetSize() == 0) |
| return MakeRecallStatusHistogram(LIST_EMPTY); |
| if (list_value.GetSize() <= kChecksumEntryCount) |
| return MakeRecallStatusHistogram(LIST_SIZE_TOO_SMALL); |
| |
| // The size is stored at the beginning of the list_value. |
| int size; |
| bool valid = (*list_value.begin())->GetAsInteger(&size); |
| if (!valid) |
| return MakeRecallStatusHistogram(LIST_SIZE_MISSING); |
| // Account for checksum and size included in the list_value. |
| if (static_cast<size_t>(size) != list_value.GetSize() - kChecksumEntryCount) |
| return MakeRecallStatusHistogram(LIST_SIZE_CORRUPTION); |
| |
| // Allocate strings for all of the logs we are going to read in. |
| // Do this ahead of time so that we can decode the string values directly into |
| // the elements of |list_|, and thereby avoid making copies of the |
| // serialized logs, which can be fairly large. |
| DCHECK(list_.empty()); |
| list_.resize(size); |
| |
| base::MD5Context ctx; |
| base::MD5Init(&ctx); |
| std::string encoded_log; |
| size_t local_index = 0; |
| for (base::ListValue::const_iterator it = list_value.begin() + 1; |
| it != list_value.end() - 1; // Last element is the checksum. |
| ++it, ++local_index) { |
| bool valid = (*it)->GetAsString(&encoded_log); |
| if (!valid) { |
| list_.clear(); |
| return MakeRecallStatusHistogram(LOG_STRING_CORRUPTION); |
| } |
| |
| base::MD5Update(&ctx, encoded_log); |
| |
| std::string log_text; |
| if (!base::Base64Decode(encoded_log, &log_text)) { |
| list_.clear(); |
| return MakeRecallStatusHistogram(DECODE_FAIL); |
| } |
| |
| DCHECK_LT(local_index, list_.size()); |
| list_[local_index].SwapLog(&log_text); |
| } |
| |
| // Verify checksum. |
| base::MD5Digest digest; |
| base::MD5Final(&digest, &ctx); |
| std::string recovered_md5; |
| // We store the hash at the end of the list_value. |
| valid = (*(list_value.end() - 1))->GetAsString(&recovered_md5); |
| if (!valid) { |
| list_.clear(); |
| return MakeRecallStatusHistogram(CHECKSUM_STRING_CORRUPTION); |
| } |
| if (recovered_md5 != base::MD5DigestToBase16(digest)) { |
| list_.clear(); |
| return MakeRecallStatusHistogram(CHECKSUM_CORRUPTION); |
| } |
| return MakeRecallStatusHistogram(RECALL_SUCCESS); |
| } |
| |
| } // namespace metrics |