Split a MetricsLogStore object out of MetricsLogManager.

components/metrics/persisted_logs.cc

 // 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 <memory>
 #include <string>
 #include <utility>
 
@@ skipping 59 matching lines @@
       min_log_bytes_(min_log_bytes),
       max_log_size_(max_log_size != 0 ? max_log_size : static_cast<size_t>(-1)),
       staged_log_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() const {
-  ListPrefUpdate update(local_state_, pref_name_);
-  WriteLogsToPrefList(update.Get());
+bool PersistedLogs::has_unsent_logs() const {
+  return !!size();
 }
 
-PersistedLogs::LogReadStatus PersistedLogs::DeserializeLogs() {
-  return ReadLogsFromPrefList(*local_state_->GetList(pref_name_));
+// True if a log has been staged.
+bool PersistedLogs::has_staged_log() const {
+  return staged_log_index_ != -1;
 }
 
-void PersistedLogs::StoreLog(const std::string& log_data) {
-  list_.push_back(LogInfo());
-  list_.back().Init(metrics_.get(),
-                    log_data,
-                    base::Int64ToString(base::Time::Now().ToTimeT()));
+// Returns the element in the front of the list.
+const std::string& PersistedLogs::staged_log() const {
+  DCHECK(has_staged_log());
+  return list_[staged_log_index_].compressed_log_data;
 }
 
-void PersistedLogs::StageLog() {
+// Returns the element in the front of the list.
+const std::string& PersistedLogs::staged_log_hash() const {
+  DCHECK(has_staged_log());
+  return list_[staged_log_index_].hash;
+}
+
+// Returns the timestamp of the element in the front of the list.
+const std::string& PersistedLogs::staged_log_timestamp() const {
+  DCHECK(has_staged_log());
+  return list_[staged_log_index_].timestamp;
+}
+
+void PersistedLogs::StageNextLog() {
   // 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_index_ = list_.size() - 1;
   DCHECK(has_staged_log());
 }
 
 void PersistedLogs::DiscardStagedLog() {
   DCHECK(has_staged_log());
   DCHECK_LT(static_cast<size_t>(staged_log_index_), list_.size());
   list_.erase(list_.begin() + staged_log_index_);
   staged_log_index_ = -1;
 }
 
+void PersistedLogs::PersistUnsentLogs() const {
+  ListPrefUpdate update(local_state_, pref_name_);
+  WriteLogsToPrefList(update.Get());
+}
+
+void PersistedLogs::LoadPersistedUnsentLogs() {
+  ReadLogsFromPrefList(*local_state_->GetList(pref_name_));
+}
+
+void PersistedLogs::StoreLog(const std::string& log_data) {
+  list_.push_back(LogInfo());
+  list_.back().Init(metrics_.get(), log_data,
+                    base::Int64ToString(base::Time::Now().ToTimeT()));
+}
+
 void PersistedLogs::Purge() {
   if (has_staged_log()) {
     DiscardStagedLog();
   }
   list_.clear();
   local_state_->ClearPref(pref_name_);
 }
 
-PersistedLogs::LogReadStatus PersistedLogs::ReadLogsFromPrefList(
-    const base::ListValue& list_value) {
-  if (list_value.empty())
-    return metrics_->RecordLogReadStatus(LIST_EMPTY);
+void PersistedLogs::ReadLogsFromPrefList(const base::ListValue& list_value) {
+  if (list_value.empty()) {
+    metrics_->RecordLogReadStatus(PersistedLogsMetrics::LIST_EMPTY);
+    return;
+  }
 
   const size_t log_count = list_value.GetSize();
 
   DCHECK(list_.empty());
   list_.resize(log_count);
 
   for (size_t i = 0; i < log_count; ++i) {
     const base::DictionaryValue* dict;
     if (!list_value.GetDictionary(i, &dict) ||
         !dict->GetString(kLogDataKey, &list_[i].compressed_log_data) ||
         !dict->GetString(kLogHashKey, &list_[i].hash)) {
       list_.clear();
-      return metrics_->RecordLogReadStatus(LOG_STRING_CORRUPTION);
+      metrics_->RecordLogReadStatus(
+          PersistedLogsMetrics::LOG_STRING_CORRUPTION);
+      return;
     }
 
     list_[i].compressed_log_data =
         DecodeFromBase64(list_[i].compressed_log_data);
     list_[i].hash = DecodeFromBase64(list_[i].hash);
     // Ignoring the success of this step as timestamp might not be there for
     // older logs.
     // NOTE: Should be added to the check with other fields once migration is
     // over.
     dict->GetString(kLogTimestampKey, &list_[i].timestamp);
   }
 
-  return metrics_->RecordLogReadStatus(RECALL_SUCCESS);
+  metrics_->RecordLogReadStatus(PersistedLogsMetrics::RECALL_SUCCESS);
 }
 
 void PersistedLogs::WriteLogsToPrefList(base::ListValue* list_value) const {
   list_value->Clear();
 
   // Keep the most recent logs which are smaller than |max_log_size_|.
   // We keep at least |min_log_bytes_| and |min_log_count_| of logs before
   // discarding older logs.
   size_t start = list_.size();
   size_t saved_log_count = 0;
@@ skipping 25 matching lines @@
     dict_value->SetString(kLogDataKey,
                           EncodeToBase64(list_[i].compressed_log_data));
     dict_value->SetString(kLogTimestampKey, list_[i].timestamp);
     list_value->Append(std::move(dict_value));
   }
   if (dropped_logs_num > 0)
     metrics_->RecordDroppedLogsNum(dropped_logs_num);
 }
 
 }  // namespace metrics