Remove the provisional store and just store the staged log when writing to

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 <string>
 
 #include "base/base64.h"
 #include "base/md5.h"
@@ skipping 47 matching lines @@
       "UMA.ProtoCompressionRatio",
       static_cast<int>(100 * compressed_log_data.size() / log_data.size()));
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "UMA.ProtoGzippedKBSaved",
       static_cast<int>((log_data.size() - compressed_log_data.size()) / 1024),
       1, 2000, 50);
 
   hash = base::SHA1HashString(log_data);
 }
 
-void PersistedLogs::LogHashPair::Clear() {
-  compressed_log_data.clear();
-  hash.clear();
-}
-
-void PersistedLogs::LogHashPair::Swap(PersistedLogs::LogHashPair* input) {
-  compressed_log_data.swap(input->compressed_log_data);
-  hash.swap(input->hash);
-}
-
 PersistedLogs::PersistedLogs(PrefService* local_state,
                              const char* pref_name,
                              const char* old_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),
       old_pref_name_(old_pref_name),
       min_log_count_(min_log_count),
       min_log_bytes_(min_log_bytes),
       max_log_size_(max_log_size != 0 ? max_log_size : static_cast<size_t>(-1)),
-      last_provisional_store_index_(-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());
@@ skipping 17 matching lines @@
 void PersistedLogs::StoreLog(const std::string& log_data) {
   list_.push_back(LogHashPair());
   list_.back().Init(log_data);
 }
 
 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;
+  staged_log_index_ = list_.size() - 1;
   DCHECK(has_staged_log());
 }
 
 void PersistedLogs::DiscardStagedLog() {
   DCHECK(has_staged_log());
-  staged_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;
+  DCHECK_LT(static_cast<size_t>(staged_log_index_), list_.size());
+  list_.erase(list_.begin() + staged_log_index_);
+  staged_log_index_ = -1;
 }
 
 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 111 matching lines @@
     return MakeRecallStatusHistogram(CHECKSUM_STRING_CORRUPTION);
   }
   if (recovered_md5 != base::MD5DigestToBase16(digest)) {
     list_.clear();
     return MakeRecallStatusHistogram(CHECKSUM_CORRUPTION);
   }
   return MakeRecallStatusHistogram(RECALL_SUCCESS);
 }
 
 }  // namespace metrics