Split a MetricsLogStore object out of MetricsLogManager.

components/ukm/ukm_service.cc

 // Copyright 2017 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/ukm/ukm_service.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 104 matching lines @@
                       kMinPersistedBytes,
                       kMaxLogRetransmitSize),
       initialize_started_(false),
       initialize_complete_(false),
       log_upload_in_progress_(false),
       self_ptr_factory_(this) {
   DCHECK(pref_service_);
   DCHECK(client_);
   DVLOG(1) << "UkmService::Constructor";
 
-  persisted_logs_.DeserializeLogs();
+  persisted_logs_.LoadPersistedUnsentLogs();
 
   base::Closure rotate_callback =
       base::Bind(&UkmService::RotateLog, self_ptr_factory_.GetWeakPtr());
   // MetricsServiceClient outlives UkmService, and
   // MetricsReportingScheduler is tied to the lifetime of |this|.
   const base::Callback<base::TimeDelta(void)>& get_upload_interval_callback =
       base::Bind(&metrics::MetricsServiceClient::GetStandardUploadInterval,
                  base::Unretained(client_));
   scheduler_.reset(new ukm::MetricsReportingScheduler(
       rotate_callback, get_upload_interval_callback));
@@ skipping 44 matching lines @@
   for (auto& provider : metrics_providers_)
     provider->OnRecordingDisabled();
 
   scheduler_->Stop();
   Flush();
 }
 
 void UkmService::Flush() {
   if (initialize_complete_)
     BuildAndStoreLog();
-  persisted_logs_.SerializeLogs();
+  persisted_logs_.PersistUnsentLogs();
 }
 
 void UkmService::Purge() {
   DVLOG(1) << "UkmService::Purge";
   persisted_logs_.Purge();
   sources_.clear();
 }
 
 void UkmService::ResetClientId() {
   client_id_ = GenerateClientId(pref_service_);
@@ skipping 22 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::FinishedInitTask";
   initialize_complete_ = true;
   scheduler_->InitTaskComplete();
 }
 
 void UkmService::RotateLog() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!log_upload_in_progress_);
   DVLOG(1) << "UkmService::RotateLog";
-  if (persisted_logs_.empty()) {
+  if (!persisted_logs_.has_unsent_logs())
     BuildAndStoreLog();
-  }
   StartScheduledUpload();
 }
 
 void UkmService::BuildAndStoreLog() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::BuildAndStoreLog";
   // Suppress generating a log if we have no new data to include.
   if (sources_.empty())
     return;
 
@@ skipping 15 matching lines @@
   }
 
   std::string serialized_log;
   report.SerializeToString(&serialized_log);
   persisted_logs_.StoreLog(serialized_log);
 }
 
 void UkmService::StartScheduledUpload() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!log_upload_in_progress_);
-  if (persisted_logs_.empty()) {
+  if (!persisted_logs_.has_unsent_logs()) {
     // No logs to send, so early out and schedule the next rotation.
     scheduler_->UploadFinished(true, /* has_unsent_logs */ false);
     return;
   }
   if (!persisted_logs_.has_staged_log())
-    persisted_logs_.StageLog();
+    persisted_logs_.StageNextLog();
   // TODO(holte): Handle data usage on cellular, etc.
   if (!log_uploader_) {
     log_uploader_ = client_->CreateUploader(
         GetServerUrl(), kMimeType, base::Bind(&UkmService::OnLogUploadComplete,
                                               self_ptr_factory_.GetWeakPtr()));
   }
   log_upload_in_progress_ = true;
 
   const std::string hash =
       base::HexEncode(persisted_logs_.staged_log_hash().data(),
@@ skipping 17 matching lines @@
   if (upload_succeeded) {
     UMA_HISTOGRAM_COUNTS_10000("UKM.LogSize.OnSuccess", log_size_bytes / 1024);
   } else if (response_code == 400) {
     // Bad syntax.  Retransmission won't work.
     discard_log = true;
   }
 
   if (upload_succeeded || discard_log) {
     persisted_logs_.DiscardStagedLog();
     // Store the updated list to disk now that the removed log is uploaded.
-    persisted_logs_.SerializeLogs();
+    persisted_logs_.PersistUnsentLogs();
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code == 400;
-  scheduler_->UploadFinished(server_is_healthy, !persisted_logs_.empty());
+  scheduler_->UploadFinished(server_is_healthy,
+                             persisted_logs_.has_unsent_logs());
 }
 
 void UkmService::RecordSource(std::unique_ptr<UkmSource> source) {
   if (!recording_enabled_) {
     RecordDroppedSource(DroppedSourceReason::RECORDING_DISABLED);
     return;
   }
   if (sources_.size() >= kMaxSources) {
     RecordDroppedSource(DroppedSourceReason::MAX_SOURCES_HIT);
     return;
   }
 
   sources_.push_back(std::move(source));
 }
 
 }  // namespace ukm