Make MetricsService save compressed logs to local state.

components/metrics/metrics_log_manager.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/metrics_log_manager.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 25 matching lines @@
 // is a long series of very small logs.
 const size_t kStorageByteLimitPerLogType = 300000;
 
 }  // namespace
 
 MetricsLogManager::MetricsLogManager(PrefService* local_state,
                                      size_t max_ongoing_log_size)
     : unsent_logs_loaded_(false),
       initial_log_queue_(local_state,
                          prefs::kMetricsInitialLogs,
+                         prefs::kMetricsInitialLogsOld,
                          kInitialLogsPersistLimit,
                          kStorageByteLimitPerLogType,
                          0),
       ongoing_log_queue_(local_state,
                          prefs::kMetricsOngoingLogs,
+                         prefs::kMetricsOngoingLogsOld,
                          kOngoingLogsPersistLimit,
                          kStorageByteLimitPerLogType,
                          max_ongoing_log_size) {}
 
 MetricsLogManager::~MetricsLogManager() {}
 
 void MetricsLogManager::BeginLoggingWithLog(scoped_ptr<MetricsLog> log) {
   DCHECK(!current_log_);
   current_log_ = log.Pass();
 }
 
 void MetricsLogManager::FinishCurrentLog() {
   DCHECK(current_log_.get());
   current_log_->CloseLog();
-  std::string log_text;
-  current_log_->GetEncodedLog(&log_text);
-  if (!log_text.empty())
-    StoreLog(&log_text, current_log_->log_type());
+  std::string log_data;
+  current_log_->GetEncodedLog(&log_data);
+  if (!log_data.empty())
+    StoreLog(log_data, current_log_->log_type());
   current_log_.reset();
 }
 
 void MetricsLogManager::StageNextLogForUpload() {
   DCHECK(!has_staged_log());
   if (!initial_log_queue_.empty())
     initial_log_queue_.StageLog();
   else
     ongoing_log_queue_.StageLog();
 }
@@ skipping 15 matching lines @@
 void MetricsLogManager::PauseCurrentLog() {
   DCHECK(!paused_log_.get());
   paused_log_.reset(current_log_.release());
 }
 
 void MetricsLogManager::ResumePausedLog() {
   DCHECK(!current_log_.get());
   current_log_.reset(paused_log_.release());
 }
 
-void MetricsLogManager::StoreLog(std::string* log,
+void MetricsLogManager::StoreLog(const std::string& log_data,
                                  MetricsLog::LogType log_type) {
   switch (log_type) {
     case MetricsLog::INITIAL_STABILITY_LOG:
-      initial_log_queue_.StoreLog(log);
+      initial_log_queue_.StoreLog(log_data);
       break;
     case MetricsLog::ONGOING_LOG:
-      ongoing_log_queue_.StoreLog(log);
+      ongoing_log_queue_.StoreLog(log_data);
       break;
   }
 }
 
 void MetricsLogManager::StoreStagedLogAsUnsent(
-    metrics::PersistedLogs::StoreType store_type) {
+    PersistedLogs::StoreType store_type) {
   DCHECK(has_staged_log());
   if (initial_log_queue_.has_staged_log())
     initial_log_queue_.StoreStagedLogAsUnsent(store_type);
   else
     ongoing_log_queue_.StoreStagedLogAsUnsent(store_type);
 }
 
 void MetricsLogManager::DiscardLastProvisionalStore() {
   // We have at most one provisional store, (since at most one log is being
   // uploaded at a time), so at least one of these will be a no-op.
@@ skipping 15 matching lines @@
 void MetricsLogManager::LoadPersistedUnsentLogs() {
   base::ElapsedTimer timer;
   initial_log_queue_.DeserializeLogs();
   ongoing_log_queue_.DeserializeLogs();
   UMA_HISTOGRAM_TIMES("UMA.LoadLogsTime", timer.Elapsed());
 
   unsent_logs_loaded_ = true;
 }
 
 }  // namespace metrics